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

Diff for /ECHO_content/VLPExtension.py between versions 1.36 and 1.53

version 1.36, 2004/11/29 20:39:25 version 1.53, 2005/12/05 14:17:59
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
   
Line 227  class VLP_essay(Folder): Line 230  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]))
Line 338  def manage_addVLP_encyc(self, id,title,l Line 342  def manage_addVLP_encyc(self, id,title,l
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
   class VLP_subcollection(ECHO_collection):
           """ subcollection of elements"""
   
           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 == "(Journal)"):
                  online =""
               else:
                  online ="AND online = 1"
               sort=self.collectionSort(type)
           
               item = [x for x in self.ZSQLSimpleSearch("""SELECT * FROM vl_literature 
                                    WHERE volumeid = '%s' """%self.getId()
                                    + """ %s AND not referenceType='%s' """%(online,type)
                                    + """ORDER BY """ + sort)]
           
               tocItem = [x for x in self.ZSQLSimpleSearch("""SELECT * FROM vl_literature 
                                    WHERE volumeid = '%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):
                   """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"      meta_type="VLP_collection"
     manage_options=ECHO_collection.manage_options+(      manage_options=ECHO_collection.manage_options+(
         {'label':'Change Path','action':'VLP_path_configForm'},          {'label':'Change Path','action':'VLP_path_configForm'},
Line 349  class VLP_collection(ECHO_collection): Line 422  class VLP_collection(ECHO_collection):
         {'label':'Update Metadata','action':'updateCollectionMD'},          {'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):      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,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>"
           RESPONSE.write("<html><body>")
           files=os.listdir(self.vlp_basis)
   
           errorsTXT+="<h3>New Ressources</h3>"
         for fileName in files:          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):
             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("<p>got: %s\n</p>"%fileName)
                 genObj=getattr(self,fileName)                  genObj=getattr(self,fileName)
                           if hasattr(genObj,'createIndexFile'):
                                   try:
                 genObj.createIndexFile()                  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:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     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 435  class VLP_resource(ECHO_resource,Cacheab Line 566  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 450  class VLP_resource(ECHO_resource,Cacheab Line 581  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,'pagesHi')):
Line 473  class VLP_resource(ECHO_resource,Cacheab Line 605  class VLP_resource(ECHO_resource,Cacheab
   
     def copyTranscriptionFromDB(self):      def copyTranscriptionFromDB(self):
         """checks if transcription exits in DB"""          """checks if transcription exits in DB"""
         founds=self.search(var='select * from vl_transcript where source=\''+self.resourceID+'\' order by id')              founds=self.ZSQLSimpleSearch('select * from vl_transcript where source=\''+self.resourceID+'\' order by id')
   
                   
         ret="""<?xml version="1.0" encoding="utf-8"?>          ret="""<?xml version="1.0" encoding="utf-8"?>
Line 482  class VLP_resource(ECHO_resource,Cacheab Line 614  class VLP_resource(ECHO_resource,Cacheab
         if founds:          if founds:
                           
             for found in founds:              for found in founds:
                           
                 text=found.transcript                  text=found.transcript
                 if not text: text=""                  if not text: text=""
                 ret+="<page><pb/>"+text+"</page>"                  ret+="<page><pb/>"+text+"</page>"
   
             ret+="</text>"              ret+="</text>"
             re2=ret[0:]              re2=ret[0:]
             re3=re2.decode('latin-1')                      re3=re2.decode('latin-1').encode('utf-8')
                                   #re3=re2
             ft=self.ZopeFind(self,obj_metatypes=['ECHO_fullText'])              ft=self.ZopeFind(self,obj_metatypes=['ECHO_fullText'])
                           
             if ft:              if ft:
                           
                 ft[0][1].pt_edit(re3.encode('utf-8','ignore'),'text/xml')                              ft[0][1].pt_edit(re3,'text/xml')
                           
             else:              else:
                 self._setObject('fulltext',ECHO_fullText(id,re3))          
                               self._setObject('fulltext',ECHO_fullText(id,''))
   
                               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()              return "FT: %s"%self.getId()
         else:          else:
Line 530  class VLP_resource(ECHO_resource,Cacheab Line 669  class VLP_resource(ECHO_resource,Cacheab
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
           
     index_html=show      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):      def generateLibraryTemplateHTML(self,RESPONSE=None):
         """lege standard index.html an"""          """lege standard index.html an"""
Line 568  class VLP_resource(ECHO_resource,Cacheab Line 713  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,'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):
         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 585  class VLP_resource(ECHO_resource,Cacheab Line 771  class VLP_resource(ECHO_resource,Cacheab
         temp=[]          temp=[]
     ret.sort()      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),os.path.splitext(x)[0]))                  temp.append((calculateName(x),os.path.splitext(x)[0]))
         return temp          return temp
Line 655  class VLP_resource(ECHO_resource,Cacheab Line 841  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 676  class VLP_resource(ECHO_resource,Cacheab Line 867  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):
Removed from v.1.36  
changed lines
  Added in v.1.53

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