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

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

version 1.27, 2004/10/05 14:58:56 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 OFS.Image import File  """
 try:  #from Products.VLP_extensions.vlp_xmlhelpers import *
     from Products.zogiLib import zogiLib  #import  Products.VLP_extensions
 except:  
     print "Zogilib not installed, VLP_resource will not work"  
   
 import xml.dom.minidom  
 import urllib  
 import xmlrpclib  
 import vlp_xmlhelpers  
 from types import *  
   
   
   
 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:          try:
             dom=xml.dom.minidom.parseString(str)      from Products.VLP_extensions.vlp_xmlhelpers import *
             return str      import  Products.VLP_extensions
         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):  
   
     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 hasattr(self,'essayTemplate.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 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('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_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('Products/ECHO_content/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('Products/ECHO_content/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_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)      class sendMailForm(Products.VLP_extensions.VLPExtension.sendMailForm):
                 genObj.createIndexFile()              pass
                                   
                                   
         if RESPONSE is not None:      class VLP_collectionFolder(Products.VLP_extensions.VLPExtension.VLP_collectionFolder):
             RESPONSE.redirect('manage_main')          pass
   
     def updateCollectionMD(self,RESPONSE=None):      class VLP_essay(Products.VLP_extensions.VLPExtension.VLP_essay):
         """updateMD"""          pass
         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:      class VLP_encyclopaedia(Products.VLP_extensions.VLPExtension.VLP_encyclopaedia):
             RESPONSE.redirect('manage_main')             pass
   
     def copyFullTextsFromDB(self,RESPONSE=None):      class VLP_subcollection(Products.VLP_extensions.VLPExtension.VLP_subcollection):
         """copy fulltext aus DB"""             pass
       class VLP_collection(Products.VLP_extensions.VLPExtension.VLP_collection):
          pass
   
         ress=self.ZopeFind(self,obj_metatypes=['VLP_resource'])      class VLP_resource(Products.VLP_extensions.VLPExtension.VLP_resource):
         ret=""          pass
         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):  
         """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 VLP_resource(ECHO_resource):  
     """VLP spezifische Erweiterung"""  
   
     meta_type="VLP_resource"  
   
     vlp_basis="/mpiwg/online/permanent/vlp"  
   
       
     referencetypes=[]  
   
     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 transcription(self):  
         """show the rendered transcriptiofile"""  
           
         if hasattr(self,'libraryTranscriptionTemplate.html'):  
             return getattr(self,'libraryTranscriptionTemplate.html')()  
   
         pt=PageTemplateFile('Products/ECHO_content/vlp/library_transcriptionTemplate.zpt').__of__(self)  
         pt.content_type="text/html"  
         return pt()  
   
   
   
     def copyTranscriptionFromDB(self):  
         """checks if transcription exits in DB"""  
         founds=self.search(var='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')  
               
             ft=self.ZopeFind(self,obj_metatypes=['ECHO_fullText'])  
               
             if ft:  
               
                 ft[0][1].pt_edit(re3.encode('utf-8','ignore'),'text/xml')  
               
             else:  
                 self._setObject('fulltext',ECHO_fullText(id,re3))  
               
             return "FT: %s"%self.getId()  
         else:  
             return "no: %s"%self.getId()  
           
     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(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 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:  
             ret=os.listdir(os.path.join(self.vlp_basis,self.resourceID,'pagesHi'))  
             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')=="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)) 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"""  
   
         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/lisePrev.gif" alt="prev" width="14" height="14" border="0"><br>prev"""  
   
         else:  
             return """<a href=%s>  
                          <img src="../../images/lisePrev.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)) 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"""  
   
         else:  
             return """<a href=%s>  
                          <img src="../../images/liseNext.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=ECHO_helpers.urlopen(url)  
         dom=xml.dom.minidom.parse(fh)  
           
           
         for page in dom.getElementsByTagName('page'):  
             text=getText(page.childNodes)  
             pageNum=page.getAttribute('nr')  
         fileName=page.getAttribute('file')  
             pagelist.append((pageNum,text,fileName))  
   
         return pagelist  
   
     def getFileName(self):  
        """getNameOfCurrentFile"""  
        try:  
         pn=int(self.REQUEST.get('pn','1'))  
        except:         except:
         pn=1     print "NO VLP extensions"
        pageinfo=self.readIndexFile()[pn-1]  
        return pageinfo[2]  
      
     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.27  
changed lines
  Added in v.1.94.2.1

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