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

Diff for /ECHO_content/VLPExtension.py between versions 1.17 and 1.94.2.1

version 1.17, 2004/08/06 11:46:30 version 1.94.2.1, 2011/10/13 07:48:27
Line 1 Line 1
 from Products.ECHO_content.ECHO_collection import *  """
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  DEPRICATED: USED NOW VLPExtension in the Product VLP_extensions
 from Products.PageTemplates.PageTemplate import PageTemplate  This module contains extensions which where originally made for the VLP.
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  definiton here are only for compatibility reasons.
   """
   #from Products.VLP_extensions.vlp_xmlhelpers import *
   #import  Products.VLP_extensions
   
 try:  try:
     from Products.zogiLib import zogiLib      from Products.VLP_extensions.vlp_xmlhelpers import *
 except:      import  Products.VLP_extensions
     print "Zogilib not installed, VLP_resource will not work"  
   
 import xml.dom.minidom  
 import urllib  
   
 def makeXML(str):  
         try:  
             dom=xml.dom.minidom.parseString(str)  
             return str  
         except:  
             return """<!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):  
   
     rc = ""  
     for node in nodelist:  
         if node.nodeType == node.TEXT_NODE:  
            rc = rc + node.data  
     return rc  
   
 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('Products/ECHO_content/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('Products/ECHO_content/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 self.REQUEST.get('p',None):  
             self.REQUEST.set('pn',self.file2page(self.REQUEST.get('p',None)))  
   
         if hasattr(self,'libraryTemplate.html'):  
             return getattr(self,'EssayTemplate.html')()  
   
         pt=PageTemplateFile('Products/ECHO_content/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 self.xml2html(makeXML(str(pages[int(pagenum)-1][1])),quote="no")  
         else:  
             return str(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 manage_addVLP_essayForm(self):  
     """Form for adding"""  
     pt=PageTemplateFile('Products/ECHO_content/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_collection(ECHO_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 VLP_path_configForm(self):  
         """change pt"""  
         path=PageTemplateFile('Products/ECHO_content/vlp/ChangeVLPPath.zpt').__of__(self)  
         return pt()  
   
     def VLP_path_config(self,path,RESPONSE=None):  
         """config"""  
         self.path=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"""  
         files=os.listdir(self.path)  
         for fileName in files:  
               
             if fileName[0:3]=="lit":  
                   
                 metalink=self.REQUEST['URL1']+"/"+fileName+"/index_meta"  
                 newObj=VLP_resource(fileName,'',metalink,fileName,fileName,fileName,'generated','book','','','','','','')  
                 self._setObject(fileName,newObj)  
                   
                 genObj=getattr(self,fileName)  
                 genObj.createIndexFile()  
                   
                   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
     def updateCollectionMD(self,RESPONSE=None):  
         """updateMD"""  
         files=os.listdir(self.path)  
         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 manage_addVLP_collectionForm(self):  
         """Form for adding a ressource"""  
         pt=PageTemplateFile('Products/ECHO_content/vlp/AddVLP_collectionForm.zpt').__of__(self)  
         return pt()  
   
   
   
 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"""  
       
   
     newObj=VLP_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")  
   
     self._setObject(id,newObj)  
     setattr(newObj,'path',path)  
   
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
       class sendMailForm(Products.VLP_extensions.VLPExtension.sendMailForm):
               pass
   
   
 class VLP_resource(ECHO_resource):      class VLP_collectionFolder(Products.VLP_extensions.VLPExtension.VLP_collectionFolder):
     """VLP spezifische Erweiterung"""          pass
   
     meta_type="VLP_resource"      class VLP_essay(Products.VLP_extensions.VLPExtension.VLP_essay):
           pass
   
     vlp_basis="/mpiwg/online/permanent/vlp"      class VLP_encyclopaedia(Products.VLP_extensions.VLPExtension.VLP_encyclopaedia):
              pass
   
       class VLP_subcollection(Products.VLP_extensions.VLPExtension.VLP_subcollection):
              pass
       class VLP_collection(Products.VLP_extensions.VLPExtension.VLP_collection):
          pass
           
     referencetypes=[]      class VLP_resource(Products.VLP_extensions.VLPExtension.VLP_resource):
           pass
   
     manage_options=ECHO_resource.manage_options+(  
         {'label':'Update Index','action':'createIndexFile'},  
         {'label':'Reset MetaLink','action':'resetMetaLink'},  
         {'label':'Generate Title','action':'generate_title'},  
     {'label':'Generate Library Template','action':'generateLibraryTemplateHTML'},  
         )  
   
     def resetMetaLink(self,all="no",RESPONSE=None):  
         """resets metalink to standard resp. in case of server change it sets to the new server url"""  
         if all=="yes":  
             self.metalink=self.absolute_url()+"/index_meta"  
         else:  
             splitted=self.metalink.split("/")  
             if (len(splitted)>1) and (splitted[len(splitted)-1]=="index_meta") and (splitted[len(splitted)-2]==self.getId()): # heuristic nur generische Metadatafiles andern  
                 self.metalink=self.absolute_url()+"/index_meta"  
   
         if RESPONSE:  
             return "done"  
               
     def show(self):  
         """show the rendered file"""  
   
         if self.REQUEST.get('p',None):  
             self.REQUEST.set('pn',self.file2page(self.REQUEST.get('p',None)))  
              
     if hasattr(self,'libraryTemplate.html'):  
         return getattr(self,'libraryTemplate.html')()  
       
         pt=PageTemplateFile('Products/ECHO_content/vlp/library_template.zpt').__of__(self)  
         pt.content_type="text/html"  
         return pt()  
       
     index_html=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):  
         """index_meta"""  
           
         pt=PageTemplateFile('Products/ECHO_content/vlp/index_meta.zpt').__of__(self)  
         pt.content_type="text/html"  
         return pt()  
   
     def file2page(self,p):  
         """converts filename to pagenumber"""  
         dom=xml.dom.minidom.parse(urllib.urlopen(getattr(self,'index.xml').absolute_url()))  
           
         for page in dom.getElementsByTagName('page'):  
             if page.getAttribute('file')==p:  
                 return page.getAttribute('nr')  
               
         return 0  
       
     def dir2index(self):  
         """dir to index"""  
   
         def calculateName(str):  
             ret="%s: %s"%(str[0],str[1:5])  
             return ret  
   
         try:  
             ret=os.listdir(os.path.join(self.vlp_basis,self.resourceID,'pageimg'))  
             self.imagePath='pageimg'  
         except:          except:
             ret=os.listdir(os.path.join(self.vlp_basis,self.resourceID,'pagesHi'))     print "NO VLP extensions"
             self.imagePath='pagesHi'  
         temp=[]  
         for x in ret:  
             if not (x[0]=="."):  
                   
                 temp.append((calculateName(x),os.path.splitext(x)[0]))  
         return temp  
   
       
     def firstPage(self,url=None):  
         """showlink to the first image"""  
         if self.REQUEST.get('pn')=="1": #erste seinte dann kein a tag  
             return """<img src="../../images/first.gif" alt="first" width="14" height="14" border="0"><br>first"""  
   
         else:  
             return """<a href=%s>  
                          <img src="../../images/first.gif" alt="first" width="14" height="14" border="0"><br>first  
                          </a>  
                          """%(self.REQUEST['URL']+"?pn=1")  
   
     def lastPage(self,url=None):  
         """showlink to the first image"""  
         pages=self.readIndexFile(url)  
         if pages:  
             ln=len(pages)  
           
         if self.REQUEST.get('pn')==str(ln): #letzte seite dann kein a tag  
             return """<img src="../../images/last.gif" alt="last" width="14" height="14" border="0"><br>last"""  
   
         else:  
             return """<a href=%s>  
                          <img src="../../images/last.gif" alt="last" width="14" height="14" border="0"><br>last  
                          </a>  
                          """%(self.REQUEST['URL']+"?pn="+str(ln))  
               
     def prevPage(self,url=None):  
         """showlink to the first image"""  
           
   
         nn = int(self.REQUEST.get('pn','1'))-1  
         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"""  
   
         else:  
             return """<a href=%s>  
                          <img src="../../images/prev.gif" alt="prev" width="14" height="14" border="0"><br>prev  
                          </a>  
                          """%(self.REQUEST['URL']+"?pn="+str(nn))  
   
     def nextPage(self,url=None):  
         """showlink to the first image"""  
         pages=self.readIndexFile(url)  
         if pages:  
             ln=len(pages)  
   
         nn = int(self.REQUEST.get('pn','1'))+1  
         if nn>int(ln): #letzte  seite dann kein a tag  
             return """<img src="../../images/next.gif" alt="next" width="14" height="14" border="0"><br>next"""  
   
         else:  
             return """<a href=%s>  
                          <img src="../../images/next.gif" alt="next" width="14" height="14" border="0"><br>next  
                          </a>  
                          """%(self.REQUEST['URL']+"?pn="+str(nn))  
           
       
     def readIndexFile(self,url=None):  
         """reads the indexfile. presently url not None isn't implemented. In the future url can be defined."""  
         pagelist=[]  
         if not url:  
             url=self.absolute_url()+"/index.xml"  
   
         fh=urllib.urlopen(url)  
         dom=xml.dom.minidom.parse(fh)  
           
           
         for page in dom.getElementsByTagName('page'):  
             text=getText(page.childNodes)  
             pageNum=page.getAttribute('nr')  
             pagelist.append((pageNum,text))  
   
         return pagelist  
       
     def createIndexFile(self,RESPONSE=None):  
         """create index file"""  
   
           
         pt=PageTemplateFile('Products/ECHO_content/vlp/index_template.zpt').__of__(self)()  
   
   
           
         if not hasattr(self,'index.xml'):  
             zt=ZopePageTemplate('index.xml')  
             self._setObject('index.xml',zt)  
         else:  
             zt=getattr(self,'index.xml')  
               
               
         zt.pt_edit(pt, 'text/xml')  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
           
 def manage_addVLP_resourceForm(self):  
         """Form for adding a ressource"""  
         pt=PageTemplateFile('Products/ECHO_content/vlp/AddVLP_resourceForm.zpt').__of__(self)  
         return pt()  
   
   
   
 def manage_addVLP_resource(self,id,title,label,description,responsible,link,metalink,weight,resourceID=None,contentType=None,renderingType=None,credits=None,coords=None,RESPONSE=None):  
     """addaresource"""  
   
       
     if metalink=='':  
         metalink=self.absolute_url()+"/"+id+"/index_meta"  
               
     newObj=VLP_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,responsible,credits,weight,coords)  
   
     self._setObject(id,newObj)  
   
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
     
Removed from v.1.17  
changed lines
  Added in v.1.94.2.1

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