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

Diff for /ECHO_content/VLPExtension.py between versions 1.2 and 1.49

version 1.2, 2004/05/27 09:31:25 version 1.49, 2005/10/11 20:10:34
Line 1 Line 1
 from ECHO_collection import *  """
   This module contains extensions which where originally made for the VLP.
   """
   from OFS.Cache import Cacheable
   from Products.ECHO_content.ECHO_collection import *
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   from OFS.Image import File
   try:
 from Products.zogiLib import zogiLib  from Products.zogiLib import zogiLib
   except:
           print "Zogilib not installed, VLP_resource will not work"
   
   import xml.dom.minidom
   import urllib
   import xmlrpclib
   import vlp_xmlhelpers
   import sys
   import os
   from stat import *
   from types import *
   from Globals import package_home
   
   
   
   def lemmatize(str):
           """takes a str and addes links the dictionary service"""
           server = xmlrpclib.ServerProxy("http://archimedes.fas.harvard.edu/cgi-bin/donatus-rpc")
           if server:
                   splitted=str.split(" ")
                   wordlist=["<w>%s</w>"%split for split in splitted].join()
           return wordlist
   
                   
   
                   
   def makeXML(str):
             
               try:
                       dom=xml.dom.minidom.parseString(str)
                       return str
               except:
                       str=str.replace("& ","&amp; ")
                       return """<?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"><page>
                                 %s
                                 </page>"""%str
               
                        
   
 def getText(nodelist):  def getText(nodelist):
   
Line 13  def getText(nodelist): Line 56  def getText(nodelist):
            rc = rc + node.data             rc = rc + node.data
     return rc      return rc
   
   class sendMailForm(ZopePageTemplate):
           """sendMailForm"""
           meta_type="sendMailForm"
   
           _default_content_fn = os.path.join(package_home(globals()), 'vlp','sendMail_template.zpt')
   
           manage_options = ZopePageTemplate.manage_options+(
           {'label':'Main Config','action':'main_configForm'},
           )
   
           main_configForm = PageTemplateFile(
       'vlp/changeSendMailForm', globals())
   
           def main_config(self, toAddrs,mailServer, subjectAdd=None, RESPONSE=None):
                   """main_config"""
                   self.toAddrs=toAddrs.split("\n")
                   self.mailServer=mailServer
                   self.subjectAdd=subjectAdd
                   if RESPONSE:
                           RESPONSE.redirect('manage_main')
   
           def sendForm(self,fromaddr,subject,content,nextPage="index_html",RESPONSE=None):
                   """sendform"""
                   fromaddr=fromaddr.strip("\r\n\t") # sicherstellen dass keine zusaetzlichen headerzeilen eingefuegt werden
                   subject=subject.strip("\r\n\t") # sicherstellen dass keine zusaetzlichen headerzeilen eingefuegt werden
                   toaddrs=self.toAddrs
   
                   subject="%s %s"%(self.subjectAdd,subject)
                   
                   msg = ("From: %s\r\nSubject: %s\r\nTo: %s\r\n\r\n"
                          % (fromaddr, subject, ", ".join(toaddrs)))
                   server = smtplib.SMTP(self.mailServer)
                   #server.set_debuglevel(1)
                   msg=msg+content
                   server.sendmail(fromaddr, toaddrs, msg)
                   server.quit()
   
                   if RESPONSE:
                           RESPONSE.redirect(nextPage)
   
   manage_addSendMailFormForm = PageTemplateFile(
       'vlp/addSendMailForm', globals(), __name__='manage_addSendMailFormFrom')
   
   from urllib import quote
   
   def manage_addSendMailForm(self, id, toAddrs,mailServer, title=None, text=None, subjectAdd=None,
                              REQUEST=None, submit=None):
       "Add a Page Template with optional file content."
       toAddrsList=toAddrs.split("\n")
       id = str(id)
       if REQUEST is None:
           self._setObject(id, sendMailForm(id, text))
           ob = getattr(self, id)
           if title:
               ob.pt_setTitle(title)
           setattr(ob,'toAddrs',toAddrsList)
           setattr(ob,'mailServer',mailServer)
           setattr(ob,'subjectAdd',subjectAdd)
           return ob
       else:
           file = REQUEST.form.get('file')
           headers = getattr(file, 'headers', None)
           if headers is None or not file.filename:
               zpt = sendMailForm(id)
           else:
               zpt = sendMailForm(id, file, headers.get('content_type'))
   
           self._setObject(id, zpt)
   
           try:
               u = self.DestinationURL()
           except AttributeError:
               u = REQUEST['URL1']
   
           if submit == " Add and Edit ":
               u = "%s/%s" % (u, quote(id))
               
           ob = getattr(self, id)
           if title:
               ob.pt_setTitle(title)
               
           setattr(ob,'toAddrs',toAddrsList)
           setattr(ob,'mailServer',mailServer)
           setattr(ob,'subjectAdd',subjectAdd)
           REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
           
   class VLP_essay(Folder):
       """classe für VLP essays"""
   
       meta_type="VLP_essay"
   
       manage_options = Folder.manage_options+(
                   {'label':'Main Config','action':'ConfigVLP_essayForm'},
                   {'label':'Generate Essay Template','action':'generateEssayTemplateHTML'},
                   )
   
       def content_html(self,type='collection'):
           """template fuer content"""
           #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
           #
           #if templates:
           #    return templates[0][1]()
           
           if hasattr(self,type+"_template"):
               obj=getattr(self,type+"_template")
               return obj()
           else:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ECHO_%s_template_standard.zpt'%type)).__of__(self)
               pt.content_type="text/html"
               return pt()
   
       def ConfigVLP_essayForm(self):
           """Form for adding"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','ChangeVLP_essay.zpt')).__of__(self)
           return pt()
   
       def ChangeVLP_essay(self,title,label,description,RESPONSE=None):
           """Change vlp_essay"""
           self.title=title
           self.label=label
           self.description=description
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def __init__(self,id,title,label):
           """init"""
           self.id=id
           self.title=title
           self.label=label
   
       def index_html(self):
           
               """show the rendered file"""
               
               if hasattr(self,'essayTemplate.html'):
                           return getattr(self,'essayTemplate.html')()
   
               pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','essay_template.zpt')).__of__(self)
               pt.content_type="text/html"
               return pt()
   
       def generateEssayTemplateHTML(self,RESPONSE=None):
           """lege standard index.html an"""
   
           if not hasattr(self,'essayTemplate.html'):
               zt=ZopePageTemplate('essayTemplate.html')
               self._setObject('essayTemplate.html',zt)
               default_content_fn = os.path.join(package_home(globals()),
                                                  'vlp/essay_template.zpt')
               text = open(default_content_fn).read()
               zt.pt_edit(text, 'text/html')
   
           else:
               return "already exists!"
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
       def getPage(self,pagenum):
           """gibt essay page mit num aus"""
           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.sort(sortFind)
           #print str(pages[int(pagenum)][1]())
           if pages[int(pagenum)-1][1].meta_type=='File':
                   
                   #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
                   #print txt.encode('utf-8')
                   
                   return self.xml2html(makeXML(txt),quote="no")
           else:
                   
                   
   
                   return self.xml2html(makeXML(pages[int(pagenum)-1][1]()),quote="no")
           
       def nextPage(self,pagenum,url):
           pages=len(self.ZopeFind(self,obj_metatypes=['DTML Document','File'])) # teste ob performance ok, sonst in variable
           if int(pagenum)+1 <= pages:
               retstr=url+"?p="+str(int(pagenum)+1)
               return """<td align="right" <a href="%s">next</a></td>"""%retstr
           
       def previousPage(self,pagenum,url):
           
           if int(pagenum)-1 > 0:
               retstr=url+"?p="+str(int(pagenum)-1)
               return """<td align="left" <a href="%s">previous</a></td>"""%retstr
           
       def nextURL(self,pagenum,url):
           pages=len(self.ZopeFind(self,obj_metatypes=['DTML Document','File'])) # teste ob performance ok, sonst in variable
           if int(pagenum)+1 <= pages:
               retstr=url+"?p="+str(int(pagenum)+1)
               return retstr
           
       def previousURL(self,pagenum,url):
           
           if int(pagenum)-1 > 0:
               retstr=url+"?p="+str(int(pagenum)-1)
               return retstr
           
           
   def manage_addVLP_essayForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','AddVLP_essay.zpt')).__of__(self)
       return pt()
   
   def manage_addVLP_essay(self, id,title,label,RESPONSE=None):
           """add the copyright"""
   
           
           self._setObject(id, VLP_essay(id, title,label))
   
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
           
   
   class VLP_encyclopaedia(VLP_essay):
           """essay"""
   
           meta_type="VLP_encyclopaedia"
           
           manage_options = VLP_essay.manage_options+(
                   {'label':'Load File','action':'loadNewFileForm'},
                   )
   
           
           def loadNewFileForm(self):
                   """Neues XML-File einlesen"""
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','VLP_newfile.zpt')).__of__(self)
                   return pt()
   
           def loadNewFile(self,RESPONSE=None):
                   """einlesen des neuen files"""
                   fileupload=self.REQUEST['fileupload']
                   if fileupload:
                           file_name=fileupload.filename
                           filedata=fileupload.read()
   
                           argv=vlp_xmlhelpers.proj2hash(self,filedata)
                           textsStr=string.join(argv['text']).encode('utf-8')
                           
                           texts=textsStr.split("<pb/>")
                           
                           i=0
                           for text in texts:
                                   i+=1
                                   pageName='page%03d.xml'%i
                                   pages=self.ZopeFind(self,obj_ids=[pageName])
                                   if pages:
                                           pages[0][1].update_data(text)
   
                                   else:
                                           zt=File(pageName,pageName,text,content_type="text/plain")
                                           self._setObject(pageName,zt)
                                   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
                           
           
   def manage_addVLP_encycForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','AddVLP_encyc.zpt')).__of__(self)
       return pt()
   
   def manage_addVLP_encyc(self, id,title,label,RESPONSE=None):
           """add the copyright"""
   
           
           self._setObject(id, VLP_encyclopaedia(id, title,label))
   
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
           
   class VLP_subcollection(ECHO_collection):
           """ subcollection of elements"""
   
           meta_type="VLP_subcollection"
           
           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):
                   """erzeuge subcollection"""
                   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)
   
   
           def index_html(self):
                   """erzeuge darstellung"""
                   
                   if hasattr(self,'subCollection_template.html'):
                           return getattr(self,'subCollection_template.html')()
   
                   pt=zptFile(self, 'vlp/subCollection_template.zpt')
                   return pt()
   
   
   def manage_addVLP_subCollection(self,id,title,label,RESPONSE=None):
   
           self._setObject(id,VLP_subcollection(id,title,label))
   
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
   
   
 class VLP_collection(ECHO_collection):  class VLP_collection(ECHO_collection):
     """VLP spezifische Erweiterung der Collection"""      """VLP spezifische Erweiterung der Collection"""
   
   
       meta_type="VLP_collection"
       manage_options=ECHO_collection.manage_options+(
           {'label':'Change Path','action':'VLP_path_configForm'},
           {'label':'Update Library','action':'updateCollection'},
           {'label':'Update Metadata','action':'updateCollectionMD'},
           )
   
   
   
       def generateSubCollections(self,errorsTXT=""):
               """erzeuge subcollectionen"""
               founds=self.ZSQLSimpleSearch("select * from vl_literature where referencetype in ('(Book)','(Collection)','(Journal)')")
               
               self.REQUEST.RESPONSE.write("<h2>Create Subcollections</h2>\n")
               for found in founds:
                       try:
                               foundCol=self.ZopeFind(self,obj_ids=[found.reference])
                               if foundCol:
   
                                       self.manage_delObjects([foundCol[0][0]])
   
                               manage_addVLP_subCollection(self,found.reference,found.titlerefdisplay,found.titlerefdisplay)
                               #getattr(self,found.reference).generateSubCollectionFromDB()
                               #teste ob es Images auf dem Server gibt mit gleichem Namen (frontmatter)
                               if os.path.exists(os.path.join(self.vlp_basis,found.reference)):
   
                                       obj=getattr(self,found.reference)
                                       if not self.ZopeFind(obj,obj_ids=[found.reference]):
                                               metalink=self.REQUEST['URL1']+"/"+found.reference+"/"+found.reference+"/index_meta"
                                               newObj=VLP_resource(found.reference,'',metalink,found.reference,found.reference,found.reference,'generated','book','','','','','','')
                                               obj._setObject(found.reference,newObj)
                                       genObj=getattr(obj,found.reference)
                                       genObj.createIndexFile()
   
                               self.REQUEST.RESPONSE.write("<p>%s</p>\n"%found.reference)
                       except:
                               error=sys.exc_info()[0:2]
                               RESPONSE.write("(ERROR (%s): %s %s)\n"%(found.reference,error[0],error[1]))
                               errorsTXT+="<p>No subcollection of %s  "+"(ERROR: %s %s)</p>"%error
   
               return errorsTXT
               
       def VLP_path_configForm(self):
           """change pt"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','ChangeVLPPath.zpt')).__of__(self)
           return pt()
   
       def VLP_path_config(self,path,RESPONSE=None):
           """config"""
           self.vlp_basis=path
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def updateCollection(self,RESPONSE=None):
           """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
           errorsTXT="<h2>Errors</h2>"
           RESPONSE.write("<html><body>")
           files=os.listdir(self.vlp_basis)
   
           errorsTXT+="<h3>New Ressources</h3>"
           for fileName in files:
               
               if fileName[0:3]=="lit":
                   
                   metalink=self.REQUEST['URL1']+"/"+fileName+"/index_meta"
                   try:
                           if not hasattr(self,fileName):
                                   newObj=VLP_resource(fileName,'',metalink,fileName,fileName,fileName,'generated','book','','','','','','')
                                   self._setObject(fileName,newObj)
                   
                           RESPONSE.write("<p>got: %s\n</p>"%fileName)
                           genObj=getattr(self,fileName)
                           if hasattr(genObj,'createIndexFile'):
                                   try:
                                           genObj.createIndexFile()
                                   except:
                                           error=sys.exc_info()[0:2]
                                           RESPONSE.write("<p>(ERROR (%s): %s %s)</p>\n"%(fileName,error[0],error[1]))
                                           errorsTXT+="<p>No indexfile of %s  "+"(ERROR: %s %s)</p>"%error
   
                           if genObj.meta_type=="VLP_subcollection":
                                   genObj.pageSizeSum=getattr(genObj,fileName).getPageSizeSum()
                           else:
                                   genObj.pageSizeSum=genObj.getPageSizeSum()
                           
                   except:
                           error=sys.exc_info()[0:2]
                           RESPONSE.write("<p>(ERROR (%s): %s %s)</p>\n"%(fileName,error[0],error[1]))
                           errorsTXT+="<p>File not created:%s  "+"(ERROR: %s %s)</p>"%error
                                   
           errorsTXT+=self.generateSubCollections()
           errorsTXT+="/n"
           RESPONSE.write(errorsTXT)
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def updateCollectionMD(self,RESPONSE=None):
           """updateMD"""
           files=os.listdir(self.vlp_basis)
           for fileName in files:
               if fileName[0:3]=="lit":
                   genObj=getattr(self,fileName)
                   genObj.copyIndex_meta2echo_resource()
                   genObj.generate_title()
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def copyFullTextsFromDB(self,RESPONSE=None):
               """copy fulltext aus DB"""
   
               ress=self.ZopeFind(self,obj_metatypes=['VLP_resource'])
               ret=""
               for res in ress:
                       tmp=res[1].copyTranscriptionFromDB()
                       ret+=tmp
   
                       if RESPONSE:
                               RESPONSE.write(tmp+"\n")
               if not RESPONSE:                
                       return ret
               else:
                       RESPONSE.write("END\n")
                       
               
 def manage_addVLP_collectionForm(self):  def manage_addVLP_collectionForm(self):
         """Form for adding a ressource"""          """Form for adding a ressource"""
         pt=PageTemplateFile('Products/ECHO_content/vlp/AddVLP_collectionForm.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','AddVLP_collectionForm.zpt')).__of__(self)
         return pt()          return pt()
   
   
   
 def manage_addVLP_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):  def manage_addVLP_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,path,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
     """add a echo collection"""      """add a echo collection"""
           
   
     newObj=VLP_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")      newObj=VLP_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
       setattr(newObj,'path',path)
   
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   
 class VLP_resource(ECHO_resource):  class VLP_resource(ECHO_resource,Cacheable):
     """VLP spezifische Erweiterung"""      """VLP spezifische Erweiterung"""
   
     meta_type="VLP_resource"      meta_type="VLP_resource"
   
     vlp_basis="/mpiwg/online/permanent/vlp"      #vlp_basis="/mpiwg/online/permanent/vlp"
   
           
     referencetypes=[]      referencetypes=[]
   
     manage_options=ECHO_resource.manage_options+(      manage_options=ECHO_resource.manage_options+Cacheable.manage_options+(
         {'label':'Update Index','action':'createIndexFile'},          {'label':'Update Index','action':'createIndexFile'},
         {'label':'Reset MetaLink','action':'resetMetaLink'},          {'label':'Reset MetaLink','action':'resetMetaLink'},
         {'label':'Generate Title','action':'generate_title'},          {'label':'Generate Title','action':'generate_title'},
           {'label':'Generate Library Template','action':'generateLibraryTemplateHTML'},
         )          )
   
   
     def printDict(self):      def getImagePath(self):
         """dict"""              """Pfad zu den Images"""
         return self.__dict__              
               if os.path.isdir(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')):
                       return os.path.join(self.vlp_basis,self.resourceID,'pagesHi')
               else:
                       return "<error>no images </error>"
       
   
               
       def transcription(self):
               """show the rendered transcriptiofile"""
               
               if hasattr(self,'libraryTranscriptionTemplate.html'):
                           return getattr(self,'libraryTranscriptionTemplate.html')()
           
     ## def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,responsible,credits,weight,coords):              pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','library_transcriptionTemplate.zpt')).__of__(self)
 ##         """angepasstes init"""              pt.content_type="text/html"
               return pt()
   
   
   
       def copyTranscriptionFromDB(self):
               """checks if transcription exits in DB"""
               founds=self.ZSQLSimpleSearch('select * from vl_transcript where source=\''+self.resourceID+'\' order by id')
   
   
               ret="""<?xml version="1.0" encoding="utf-8"?>
                  <text>"""
           
               if founds:
                       
                       for found in founds:
                           
                               text=found.transcript
                               if not text: text=""
                               ret+="<page><pb/>"+text+"</page>"
   
                       ret+="</text>"
                       re2=ret[0:]
                       re3=re2.decode('latin-1').encode('utf-8')
                       #re3=re2
                       ft=self.ZopeFind(self,obj_metatypes=['ECHO_fullText'])
                       
                       if ft:
                           
                               ft[0][1].pt_edit(re3,'text/xml')
                           
                       else:
                   
                               self._setObject('fulltext',ECHO_fullText(id,''))
                           
 ##         return ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,responsible,credits,weight,coords)                              try:
                                   getattr(self,'fulltext').pt_edit(re3.encode('utf-8','ignore'),'text/xml')
                               except:
                                   getattr(self,'fulltext').pt_edit(re3.encode('latin-1').decode('utf-8'),'text/xml')
   
                       return "FT: %s"%self.getId()
               else:
                       return "no: %s"%self.getId()
                   
     def resetMetaLink(self,all="no",RESPONSE=None):      def resetMetaLink(self,all="no",RESPONSE=None):
         """resets metalink to standard resp. in case of server change it sets to the new server url"""          """resets metalink to standard resp. in case of server change it sets to the new server url"""
Line 79  class VLP_resource(ECHO_resource): Line 625  class VLP_resource(ECHO_resource):
                           
     def show(self):      def show(self):
         """show the rendered file"""          """show the rendered file"""
         pt=PageTemplateFile('Products/ECHO_content/vlp/library_template.zpt').__of__(self)  
           if 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)))
   
              
           if hasattr(self,'libraryTemplate.html'):
                   return getattr(self,'libraryTemplate.html')()
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','library_template.zpt')).__of__(self)
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
           
       def index_html(self):
               """index_html"""
               #return self.REQUEST
               if not self.REQUEST.has_key("ws"):
                       self.REQUEST.form["ws"]="1.5"
   
               return self.show()
   
       def generateLibraryTemplateHTML(self,RESPONSE=None):
           """lege standard index.html an"""
   
           if not hasattr(self,'libraryTemplate.html'):
               zt=ZopePageTemplate('libraryTemplate.html')
               self._setObject('libraryTemplate.html',zt)
               default_content_fn = os.path.join(package_home(globals()),
                                                  'vlp/library_template.zpt')
               text = open(default_content_fn).read()
               zt.pt_edit(text, 'text/html')
   
           else:
               return "already exists!"
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
           
     def index_meta(self):      def index_meta(self):
         """index_meta"""          """index_meta"""
         pt=PageTemplateFile('Products/ECHO_content/vlp/index_meta.zpt').__of__(self)          
           pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','index_meta.zpt')).__of__(self)
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
           
       def file2page(self,p):
           """converts filename to pagenumber"""
           dom=xml.dom.minidom.parse(ECHO_helpers.urlopen(getattr(self,'index.xml').absolute_url()))
           
           for page in dom.getElementsByTagName('page'):
                    # pageummer mit lo oder hi sind aequivalent
                    if (page.getAttribute('file')==p) or ("%slo"%page.getAttribute('file')==p) or ("%shi"%page.getAttribute('file')==p):
                            return page.getAttribute('nr')
               
           return 0
   
       def getPageSizeSum(self):
               """generate average page size"""
   
               #size of hi resolution
               files=[]
               try:
                       pathHi=os.path.join(self.vlp_basis,self.resourceID,'pagesHi')
                       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']
                   
           
         def calculateName(str):          def calculateName(str):
             ret="%s: %s"%(str[0],str[1:5])              name=os.path.splitext(str[1:])[0]
               ret="%s: %s"%(str[0],name)
             return ret              return ret
   
         try:          try:
Line 105  class VLP_resource(ECHO_resource): Line 738  class VLP_resource(ECHO_resource):
             ret=os.listdir(os.path.join(self.vlp_basis,self.resourceID,'pagesHi'))              ret=os.listdir(os.path.join(self.vlp_basis,self.resourceID,'pagesHi'))
             self.imagePath='pagesHi'              self.imagePath='pagesHi'
         temp=[]          temp=[]
           ret.sort()
         for x in ret:          for x in ret:
             if not (x[0]=="."):              if (not (x[0]==".")) and (not x[0:4] in excludeNames):
                                   
                 temp.append(calculateName(x))                  temp.append((calculateName(x),os.path.splitext(x)[0]))
         return temp          return temp
   
       
     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": #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')
             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")                           """%(self.REQUEST['URL']+"?pn=1&ws=%s"%ws)
   
     def lastPage(self,url=None):      def lastPage(self,url=None):
         """showlink to the first image"""          """showlink to the first image"""
Line 128  class VLP_resource(ECHO_resource): Line 764  class VLP_resource(ECHO_resource):
         if pages:          if pages:
             ln=len(pages)              ln=len(pages)
                   
         if self.REQUEST.get('pn')==str(ln): #letzte seite dann kein a tag          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')
             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))                           """%(self.REQUEST['URL']+"?pn="+str(ln)+"&ws="+ws)
                           
     def prevPage(self,url=None):      def prevPage(self,url=None):
         """showlink to the first image"""          """showlink to the first image"""
Line 143  class VLP_resource(ECHO_resource): Line 780  class VLP_resource(ECHO_resource):
   
         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/prev.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')
             return """<a href=%s>              return """<a href=%s>
                          <img src="../../images/prev.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))                           """%(self.REQUEST['URL']+"?pn="+str(nn)+"&ws="+ws)
   
     def nextPage(self,url=None):      def nextPage(self,url=None):
         """showlink to the first image"""          """showlink to the first image"""
Line 158  class VLP_resource(ECHO_resource): Line 796  class VLP_resource(ECHO_resource):
             ln=len(pages)              ln=len(pages)
   
         nn = int(self.REQUEST.get('pn','1'))+1          nn = int(self.REQUEST.get('pn','1'))+1
         if nn>int(ln): #letzte  seite dann kein a tag          if (nn>int(ln)) or (ln==1): #letzte  seite dann kein a tag
             return """<img src="../../images/next.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')
             return """<a href=%s>              return """<a href=%s>
                          <img src="../../images/next.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))                           """%(self.REQUEST['URL']+"?pn="+str(nn)+"&ws="+ws)
                   
           
     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."""
         pagelist=[]  
         if not url:          if not url:
             url=self.absolute_url()+"/index.xml"              url=self.absolute_url()+"/index.xml"
   
         fh=urllib.urlopen(url)          if self.ZCacheable_isCachingEnabled():
               
               result = self.ZCacheable_get(view_name=url)
               if result is not None:
                   # Got a cached value.
                   return result
   
           pagelist=[]
      
           fh=ECHO_helpers.urlopen(url)
         dom=xml.dom.minidom.parse(fh)          dom=xml.dom.minidom.parse(fh)
                   
                   
         for page in dom.getElementsByTagName('page'):          for page in dom.getElementsByTagName('page'):
             text=getText(page.childNodes)              text=getText(page.childNodes)
             pageNum=page.getAttribute('nr')              pageNum=page.getAttribute('nr')
             pagelist.append((pageNum,text))              fileName=page.getAttribute('file')
               pagelist.append((pageNum,text,fileName))
   
           self.ZCacheable_set(pagelist,view_name=url)
         return pagelist          return pagelist
           
       def getFileName(self):
              """getNameOfCurrentFile"""
              try:
               pn=int(self.REQUEST.get('pn','1'))
              except:
               pn=1
              pageinfo=self.readIndexFile()[pn-1]
              return pageinfo[2]
      
     def createIndexFile(self,RESPONSE=None):      def createIndexFile(self,RESPONSE=None):
         """create index file"""          """create index file"""
   
                   
         pt=PageTemplateFile('Products/ECHO_content/vlp/index_template.zpt').__of__(self)()          pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','index_template.zpt')).__of__(self)()
   
   
                   
Line 208  class VLP_resource(ECHO_resource): Line 866  class VLP_resource(ECHO_resource):
                   
 def manage_addVLP_resourceForm(self):  def manage_addVLP_resourceForm(self):
         """Form for adding a ressource"""          """Form for adding a ressource"""
         pt=PageTemplateFile('Products/ECHO_content/vlp/AddVLP_resourceForm.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','AddVLP_resourceForm.zpt')).__of__(self)
         return pt()          return pt()
   
   
Removed from v.1.2  
changed lines
  Added in v.1.49

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