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

Diff for /ECHO_content/ECHO_resource.py between versions 1.6.2.5 and 1.9

version 1.6.2.5, 2012/08/29 07:53:31 version 1.9, 2012/01/04 13:23:00
Line 1 Line 1
 #TODO: change metaDataHash, jetzt tag -> data(tags aus dem neuen Metadatamain)  
 #TODO: contentType aus den Metadaten  
   
 import urlparse  import urlparse
 import string  import string
 import tempfile  import tempfile
Line 35  import urllib2 Line 32  import urllib2
 import cgi  import cgi
 import smtplib  import smtplib
 import time  import time
 #from Ft.Xml.Domlette import NonvalidatingReader  from Ft.Xml.Domlette import NonvalidatingReader
 #from Ft.Xml.Domlette import PrettyPrint, Print  from Ft.Xml.Domlette import PrettyPrint, Print
 #from Ft.Xml import EMPTY_NAMESPACE  from Ft.Xml import EMPTY_NAMESPACE
 #  
 #import Ft.Xml.XPath  import Ft.Xml.XPath
 import cStringIO  import cStringIO
   
 import sys  import sys
Line 61  from ECHO_helpers import * Line 58  from ECHO_helpers import *
   
   
 from ECHO_movie import *  from ECHO_movie import *
 #import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen  import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
 import xmlrpclib  import xmlrpclib
   
 import logging  import logging
Line 75  class ECHO_resource(CatalogAware,Folder, Line 72  class ECHO_resource(CatalogAware,Folder,
     #    viewClassificationList=viewClassificationListMaster      #    viewClassificationList=viewClassificationListMaster
           
   
            
     def PrincipiaSearchSource(self):      def PrincipiaSearchSource(self):
            """Return cataloguable key for ourselves."""             """Return cataloguable key for ourselves."""
            return str(self)             return str(self)
   
     getSubCols = ECHO_helpers.getSubCols      getSubCols = ECHO_helpers.getSubCols
           
 #    def getMetaDataManager(self):  
 #        """hole eine Instanz von MetaDataFolder  
 #        TODO: sollte konfigurierbar sein.   
 #        zur Zeit wird enfach nur self.metadata falls vorhanden zurueckggegeben.  
 #        """  
 #     
 #        mf= getattr(self,"metadataFolder",None)  
 #        #logging.debug("MetadataManager:"+repr(mf))  
 #        return mf  
 #          
   
     def index_meta(self,RESPONSE=None):      def index_meta(self,RESPONSE=None):
         """ gibt das im metalink gespeicher xml-file zurueck"""          """ gibt das im metalink gespeicher xml-file zurueck"""
         url = self.metalink          url = self.metalink
Line 135  class ECHO_resource(CatalogAware,Folder, Line 120  class ECHO_resource(CatalogAware,Folder,
         self.reindex_object()          self.reindex_object()
       
       
       security.declareProtected('View','createPDF')
       def createPDF(self,RESPONSE=None,local=None,dpi=150):
               """erzeuge pdf file"""
               pages=1
               dpi=float(dpi)
               imagePath=self.getImagePath().replace("/mpiwg/online","")
               
               
               image="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn="+imagePath+"&dw=%i&dh=%i&pn=%i"
               xmlInfo="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/dlInfo-xml.jsp?fn="+imagePath
   
               dom=xml.dom.minidom.parse(urllib.urlopen(xmlInfo))
               for parameter in dom.getElementsByTagName('parameter'):
                       if parameter.getAttribute('name')=="pt":
                               pages=int(parameter.getAttribute('value'))
                               break
               
   
               tempdir="/tmp/archivesImageServer"
               if not os.path.exists(tempdir):
                       os.mkdir(tempdir) 
     
               tmpPath=tempfile.mkdtemp(dir=tempdir)
               
   
               tmpZip=tempfile.mktemp(dir=tempdir)
   
               tmpFn=os.path.split(tmpZip)[1]
   
   
       
   
               if RESPONSE:
                       RESPONSE.setHeader("Content-Type","text/html")
                       RESPONSE.write("<h1>I am creating  the pdf</h1>")
                       txt="<h3>1. step: getting the images( %i pages)</h3>"%pages
                       RESPONSE.write(txt)
   
               c=canvas.Canvas(tmpZip)
               for i in range(1,pages+1):
                       if RESPONSE:
                               RESPONSE.write(str("<p>Get Page: %i<br>\n"%i))
                       faktor=dpi/72.0
                       
                       fn=tmpPath+"/%i"%i
   
                       width,height=A4
                       #print image%(width*faktor,height*faktor,i)
                       url=urllib.urlopen(image%(width*faktor,height*faktor,i)).read()
                       fh=file(fn,"w")
                       fh.write(url)
                       fh.close()
   
       
   
                       c.drawImage(fn,0,0,width=width,height=height)
                       c.showPage()
               c.save()
               if RESPONSE:
                       RESPONSE.write("<p>finished<br>\n")
   
               if RESPONSE:
                       len=os.stat(tmpZip)[6]
                       downloadUrl=self.absolute_url()+"/downloadPDF"
                       RESPONSE.write("""<h1><a href="downloadPDF?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))
                       RESPONSE.write("""<p>The file will be stored for a while, you can download it later, the URL is:</p>
                       <p><a href="downloadPDF?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn))
                       RESPONSE.close()
   
   
       def downloadPDF(self,fn):
               """download prepared set"""
               filename="/tmp/archivesImageServer/"+fn
               namePDF=self.getId()+".pdf"
               self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%namePDF)
               self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
               len=os.stat(filename)[6]
               self.REQUEST.RESPONSE.setHeader("Content-Length",len)
               images=file(filename).read()
               self.REQUEST.RESPONSE.write(images)
               self.REQUEST.RESPONSE.close()
     
   
     def getRDF(self,urn=None):      def getRDF(self,urn=None):
Line 226  class ECHO_resource(CatalogAware,Folder, Line 292  class ECHO_resource(CatalogAware,Folder,
                           
                           
                           
       def getMetaLink(self):
           return self.metalink
   
       def setMetaLink(self,ml):
           self.metalink=ml
           return
           
     def getAccessRightMD(self):      def getAccessRightMD(self):
                 """set accessright"""                  """set accessright"""
Line 358  class ECHO_resource(CatalogAware,Folder, Line 430  class ECHO_resource(CatalogAware,Folder,
                     
                 server.writeMetaDataFile(path,string,"yes")                  server.writeMetaDataFile(path,string,"yes")
                   
       def setStartPageForm(self):
               """Form for changing the startpage"""
   
               
               pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPage.zpt')
               pt.content_type="text/html"
               return pt()
       
   
     def createImageUrl(self,pn=1):      def createImageUrl(self,pn=1):
             """create ImageUrl"""              """create ImageUrl"""
Line 406  class ECHO_resource(CatalogAware,Folder, Line 486  class ECHO_resource(CatalogAware,Folder,
                             return None,self.absolute_url()                              return None,self.absolute_url()
   
                           
       def setStartPage(self,startpage=None,RESPONSE=None):
               """set start page, if no startpage defined use the generic one of the resource"""
   
               if (not (type(startpage)==StringType)):
                       if ("__generic" in startpage): # checke ob generic in der liste
                               startpage=self.absolute_url()+"/startpage_html"
                       elif ("__firstPage" in startpage): # checke ob generic in der liste
                               startpage=self.createImageUrl()
                               
               if (not startpage):
                       startpage=self.absolute_url()+"/startpage_html"
               elif (startpage=="__generic"):
                       startpage=self.absolute_url()+"/startpage_html"
               elif (startpage=="__firstPage"):
                           startpage=self.createImageUrl()
       
               params="startpage=%s"%startpage
               #print 'http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))
                  
               tries=0
               for i in range(10):
                       x=ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()
                       if x=="ok":
                              
                               break;
                    
               
               path=self.metalink
               
               path=re.sub(self.REQUEST['SERVER_URL'],'',path)
               path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
   
               path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
               path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
               path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
               path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
               path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
               path=re.sub('http://vision.mpiwg-berlin.mpg.de','',path) # falls vision als server
               path=re.sub('http://xserve02.mpiwg-berlin.mpg.de:18880','',path) # falls vision als server
               path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
               path=re.sub('/index.meta','',path) 
   
   
               ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
   
               if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
       def changeViewerTemplateSetForm(self):
               """change the viewer template set"""
               pt=zptFile(self, 'zpt/changeResourceViewerTemplateSet')
               return pt()
   
   
     def setLink(self, link=None):      def setLink(self, link=None):
Line 433  class ECHO_resource(CatalogAware,Folder, Line 564  class ECHO_resource(CatalogAware,Folder,
             return default              return default
         
   
       def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
               """changeit"""
   
               paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate','digiliburlprefix']
   
               
               #writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)
   
               params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
   
               try:
                   tries=0
                   for i in range(10):
                           x=ECHO_helpers.urlopen('http://echo.mpiwg-berlin.mpg.de/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()
                           if x=="ok":
                              
                               break;
                    
               except:
                   logger("ECHO_ressource (changeViewerTemplateSet)", logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])          
                   logger("ECHO_ressource (changeViewerTemplateSet)", logging.ERROR,'http://echo.mpiwg-berlin.mpg.de/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params)))
               #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)
               # hack Pfad auf die Dokumente
               path=self.metalink
               
               
   
               path=re.sub('/index.meta','',path) 
   
               #TODO: direct access to the file system necessary, fix that also xmlrpc to the server where the index file is stored is possible    
               parsedUrl=urlparse.urlparse(path)
               path=parsedUrl[2]
   
               try:        
                   return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
               except:
                   logger("ECHO_Resource (changeViewerTemplateSet)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
                   logger("ECHO_Resource (changeViewerTemplateSet)", logging.INFO,"http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path)
   
               if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
   
   
     security.declarePublic('content_html')            security.declarePublic('content_html')      
Line 455  class ECHO_resource(CatalogAware,Folder, Line 628  class ECHO_resource(CatalogAware,Folder,
                     #logger("ECHO Fulltext",logging.INFO,"opened %s"%self.metalink)                      #logger("ECHO Fulltext",logging.INFO,"opened %s"%self.metalink)
                     dom=xml.dom.minidom.parse(fh)                      dom=xml.dom.minidom.parse(fh)
                     texttools=dom.getElementsByTagName('texttool')                      texttools=dom.getElementsByTagName('texttool')
                       
   
                       text=texttools[0].getElementsByTagName('text-url-path') #pfad auf text im neuen system
                       logging.debug(text);
                       if (text is not None) and len(text)>0:
                           texturl=getText(text[0].childNodes)
                           textBasisUrl=None
                           if hasattr(self,"getFullTextBasisUrl"):
                               textBasisUrl=self.getFullTextBasisUrl()
                           else: #default
                               textBasisUrl="http://mpdl-text.mpiwg-berlin.mpg.de/mpdl/getDoc?doc=%s"
                           #Beispiel http://mpdl-text.mpiwg-berlin.mpg.de/mpdl/getDoc?doc=/archimedes/la/achil_propo_087_la_1545.xml
                           logging.debug(textBasisUrl);
                           texturl=textBasisUrl%texturl
                       else:
                     text=texttools[0].getElementsByTagName('text')                      text=texttools[0].getElementsByTagName('text')
                     texturl=getText(text[0].childNodes)                      texturl=getText(text[0].childNodes)
   
                        #TODO: hack has to be romoved, if index.meta for annalen are changed!! (DW)
                if (texturl is not None) and (texturl.startswith("/mpiwg/online/permanent/einstein/annalen")):
                     texturl=texturl.replace("/mpiwg/online/permanent/einstein/annalen/","/diverse/de/") 
                                 splitted=texturl.split("/fulltext")
                                 texturl=splitted[0]+".xml"
                         if hasattr(self,"getFullTextBasisUrl"):
                                   textBasisUrl=self.getFullTextBasisUrl()
                         else: #default                                                                                                                            
                                   textBasisUrl="http://mpdl-text.mpiwg-berlin.mpg.de/mpdl/getDoc?doc=%s"
                                   #Beispiel http://mpdl-text.mpiwg-berlin.mpg.de/mpdl/getDoc?doc=/archimedes/la/achil_propo_087_la_1545.xml                                 
                                 logging.debug(textBasisUrl);
                                 texturl=textBasisUrl%texturl
                        
     
   
   
                     #logger("ECHO Fulltext",logging.INFO,"found %s"%texturl)                      #logger("ECHO Fulltext",logging.INFO,"found %s"%texturl)
                     fh.close()                      fh.close()
                     #logger("ECHO Fulltext",logging.INFO,"closed fh")                      #logger("ECHO Fulltext",logging.INFO,"closed fh")
Line 475  class ECHO_resource(CatalogAware,Folder, Line 679  class ECHO_resource(CatalogAware,Folder,
                     else:                      else:
                             return texturl                              return texturl
             except:              except:
               logging.debug(sys.exc_info()[0])
               logging.debug(sys.exc_info()[1])
               logging.debug(sys.exc_info()[2])
                     if not noredirect:                      if not noredirect:
                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')                              self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
                             self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")                              self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
Line 593  class ECHO_resource(CatalogAware,Folder, Line 799  class ECHO_resource(CatalogAware,Folder,
             return []              return []
   
   
 #    def getStorageManagerResourceURL(self):      def getStorageManagerResourceURL(self):
 #        """get the link to storage"""          """get the link to storage"""
 #        urlbase=self.getStorageManagerURL();          urlbase=self.getStorageManagerURL();
 #                  
 #        #now get the path from the metadatalink          #now get the path from the metadatalink
 #                  
 #        path = self.correctPath(self.getMetaDataLink())          path = self.correctPath(self.getMetaDataLink())
 #        if path is None:          if path is None:
 #            return ""              return ""
 #        else:          else:
 #            path=path.replace("index.meta","")              path=path.replace("index.meta","")
 #            return urlbase+path              return urlbase+path
 #                  
                   
     def correctPath(self,path):      def correctPath(self,path):
         #take only the path of the url which starts with /permanent or /experimental          #take only the path of the url which starts with /permanent or /experimental
Line 695  class ECHO_resource(CatalogAware,Folder, Line 901  class ECHO_resource(CatalogAware,Folder,
         pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')          pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')
         return pt()          return pt()
   
       def ECHO_resource_config_metadata(self):
           """Main configuration"""
           if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
                   self.metaDataHash={}
                   self.contentType=self.bib_type
                   for data in self.metadata:
                           data_neu=re.sub('-','_',data)
                           self.metaDataHash[data_neu]=getattr(self,data)[0:]
   
           
           pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')
           return pt()
   
   
           
     def changeViewer(self,newViewer):      def changeViewer(self,newViewer):
         """set newViewer to the url of the new viewer          """set newViewer to the url of the new viewer
Line 705  class ECHO_resource(CatalogAware,Folder, Line 925  class ECHO_resource(CatalogAware,Folder,
                   
         vl,msg=self.checkValidityOfMetaLink()          vl,msg=self.checkValidityOfMetaLink()
                   
   
   
   
         if not vl: #ungueltiger link, versuche neuen          if not vl: #ungueltiger link, versuche neuen
             newStr=re.match(".*/mpiwg/online/(.*)",self.metalink) # suche pfad hinter /mpiwg/online               newStr=re.match(".*/mpiwg/online/(.*)",self.metalink) # suche pfad hinter /mpiwg/online 
             oldLink=self.metalink              oldLink=self.metalink
Line 722  class ECHO_resource(CatalogAware,Folder, Line 945  class ECHO_resource(CatalogAware,Folder,
             logging.info("change Viewer (mew Metadatafile) %s"%self.metalink)              logging.info("change Viewer (mew Metadatafile) %s"%self.metalink)
                         
         if vl:          if vl:
   
             self.newViewer=newViewer              self.newViewer=newViewer
             return vl,msg              return vl,msg
         else:          else:
Line 806  class ECHO_resource(CatalogAware,Folder, Line 1030  class ECHO_resource(CatalogAware,Folder,
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
        def changeECHO_resource_metadata_local(self,RESPONSE=None):
     def changeECHO_resource_metadata(self,RESPONSE=None):  
             """change metadata"""              """change metadata"""
               tags=self.findTagsFromMapping(normalizeCt(self.contentType))
               for field in tags[1]:
                       self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]
                           
             self.copyIndex_meta2echo_resource()  
             tags=mappedData.keys()  
                           
                       
             for field in tags:              if RESPONSE is not None:
                     try:                      RESPONSE.redirect('manage_main')
                             self.metaDataHash[field]=self.REQUEST.form[field]  
                                           
       def changeECHO_resource_metadata(self,RESPONSE=None):
               """change metadata"""
               tags=self.findTagsFromMapping(normalizeCt(self.contentType))
               self.OSAS_meta={}
               for field in tags[1]:
                       try:
                               self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
                               self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
                     except:                      except:
                             logger("ECHO_collection (changeECHO_resource_metadata)",logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])                              logger("ECHO_collection (changeECHO_resource_metadata)",logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])
   
Line 836  class ECHO_resource(CatalogAware,Folder, Line 1067  class ECHO_resource(CatalogAware,Folder,
           
   
     def getMDValueSimpleSearchField(self):      def getMDValueSimpleSearchField(self):
             """returns value for simple search aus DC daten"""              """returns value for simple search"""
               
               try:
                   return " ".join([self.getMDValue('title',generic="yes"),
                                self.getMDValue('author',generic="yes"),
                                self.getMDValue('year',generic="yes"),self.getTitle()])
               except:
                   
                   #logger(" ECHO_collection(getMDSimpleSearchField)",logging.INFO," ".join([self.getMDValue('title',generic="yes"),
                    #            self.getMDValue('author',generic="yes"),
                     #           self.getMDValue('year',generic="yes"),'']))
                   return ""
                                
       def getMDValue(self,fieldNameTest,empty=None,generic=None):
               """get md values"""
               #TODO: cache mappinghash
               
               fieldName=None
               if generic:
                   if self.contentType:
                       ct=self.contentType.replace(" ","_").lower()
                       ct=self.contentType.replace("-","_").lower()
                   else:
                       logger("ECHO_collection (getMDValue)", logging.INFO, "no_content type for %s"%self.getId())
                       ct=""
                       
                   #caching
                   if not hasattr(self,'_v_mapHash'): #noch keine cachevariable
                       self._v_mapHash={}
                   
                   
                           
                   tmp=self._v_mapHash.get(ct,None) 
                   if tmp: #teste ob type schon existiert
                       fieldName=tmp.get(fieldNameTest,None)
                   else:
                       self._v_mapHash[ct]={}
                       
   
                   #noch nicht gecached    
                   if not fieldName and hasattr(self.getStandardMD(),ct):    
                       fieldName=getattr(self.getStandardMD(),ct).generateMappingHash()[fieldNameTest][0]
                       self._v_mapHash[ct][fieldNameTest]=fieldName
               if not fieldName:
                   fieldName=fieldNameTest  
               if not empty:
                              #FIXME: warum gibt es manchmal kein metadatahas
             try:              try:
                 bibdata=self.getMetaDataManager().getBibData(path=self.getMetaDataLink())  
                 dcMapped = self.getMetaDataManager().getDCMappedData(bibdata)  
                 logging.debug("getMDValueSimpleSearchField:"+ repr(dcMapped))  
                 return " ".join([dcMapped.get('title',''),  
                              dcMapped.get('creator',''),  
                              dcMapped.get('year',''),self.getTitle()])  
                           
                       ret =self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%normalizeCt(self.contentType))
             except:              except:
                 logging.error("getMDValueSimpleSearchField doesn't work:"+self.getId())                      logger("ECHO (line 1069)",logging.ERROR,"no md hash for %s"%self.getId()) 
                       return ""
                     
               else:
   
                                   
                      ret= self.metaDataHash.get(fieldNameTest,empty)
              
               return unicodify(ret)
   
       getFieldValue=getMDValue #depricated
   
     def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):      def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
             """new index.meta"""              """new index.meta"""
Line 857  class ECHO_resource(CatalogAware,Folder, Line 1137  class ECHO_resource(CatalogAware,Folder,
             if not hasattr(self,'metaDataHash'):              if not hasattr(self,'metaDataHash'):
                                   
                     self.copyIndex_meta2echo_resource()                      self.copyIndex_meta2echo_resource()
               try:
   
   
                       return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
               except:
                       #print self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix
                           
             return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)              return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
   
Line 918  class ECHO_resource(CatalogAware,Folder, Line 1204  class ECHO_resource(CatalogAware,Folder,
                           
     manage_options = (      manage_options = (
         {'label':'Main Config','action':'ECHO_resource_config_main'},          {'label':'Main Config','action':'ECHO_resource_config_main'},
         {'label':'Edit Metadata','action':'ECHO_getResourceMD'},          {'label':'Change Local Metadata','action':'ECHO_resource_config_metadata'},
           {'label':'Sync Metadata with Repository','action':'ECHO_getResourceMD'},
         {'label':'Graphic Coords','action':'ECHO_graphicEntry'},          {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
           {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
         {'label':'set/change startpage','action':'setStartPageForm'},          {'label':'set/change startpage','action':'setStartPageForm'},
           {'label':'Copy MD for indexing and search','action':'copySearchFields'},
         {'label':'Change AccessRights','action':'changeAccessRightForm'},           {'label':'Change AccessRights','action':'changeAccessRightForm'}, 
         ) + Folder.manage_options          ) + Folder.manage_options
   
   
       def isDefinedInThisSet(self,fields,field):
               """checks if field is defined in fields"""
               if (fields[0].has_key(field)) and not (fields[0][field]==""):
                       return 1
               else:
                     
                       return 0
               
       def getFieldLabel(self,fields,field):
           """get labels"""
           try:
               ret =fields[0][field]
               if ret == "":
                   return field
               else:
                   return ret
           except:
               return field
   
   
   
       def getFieldTag(self,fields,field):
           """get labels"""
           try:
               ret =fields[0][field]
               if ret == "":
                   return field
               else:
                   return ret
           except:
               return field
                           
   
   
Line 933  class ECHO_resource(CatalogAware,Folder, Line 1253  class ECHO_resource(CatalogAware,Folder,
                         
             return getattr(self,'metaDataHash',{})              return getattr(self,'metaDataHash',{})
                         
     def getMetaDataValue(self,fieldName):      def setFieldValue(self,field,value):
           """get value"""
           #TODO: remove setFieldValue
           
           if not hasattr(self,'metaDataHash'):
                   setattr(self,'metaDataHash',{})
           self.metaDataHash[field]=value[0:]
   
       def copySearchFields(self):
               """copys metadatafields to the object"""
               
               # Zunaechst die gnerischen felder
               fields=['author','title','year']
               for field in fields:
                   setattr(self,'MD_'+field,self.getMDValue(field,generic="yes"))
                       
               # jetzt die spezifischen
               for field in self.getMetaDataHash().keys():
                       
                       if (not field is None) and (not (field in fields)):
                           logging.debug("ECHO_resource (copySearchFields) mapping: "+field)
                           logging.debug("ECHO_resource (copySearchFields) mapping value : "+self.getMDValue(field))
                           setattr(self,'MD_'+field,self.getMDValue(field))
       
               
                   
         self.copyIndex_meta2echo_resource()  
         return self.metaDataHash.get(fieldName,{}).get('value','')  
                   
     def findLabelsFromMapping(self,referenceType):      def findLabelsFromMapping(self,referenceType):
         """gib hash mit label -> generic zurueck"""          """gib hash mit label -> generic zurueck"""
         #return {},[]          #return {},[]
         mo=self.getMetaDataManager().getBibMapping(referenceType)  
                   
         if mo is None:          temp=self.ZopeFind(self.getStandardMD())
             return [],{}       
           if referenceType=="":
                   referenceType="book"
           
           
           bibdata={}
           retdata={}
           fields=[]
           fieldlist=self.getStandardMD().fieldList
   
           tags=self.findTagsFromMapping(normalizeCt(self.contentType))
           logging.debug("ECHO_resource(findLabelsFromMapping)"+repr(tags))
           self.referencetypes=tags[2]
           for referenceTypeF in self.referencetypes:
                   
                   logging.debug("--- compare"+normalizeCt(referenceTypeF[1].title)+normalizeCt(referenceType.lower()))
                   if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
                           
                           try:
                                   bibdata[referenceTypeF[1].title]=referenceTypeF[1].getUsedFields()
                                   referenceType=referenceTypeF[1].title
                                   logging.debug("------fields:"+repr(bibdata[referenceTypeF[1].title]))
                           except:
                                   bibdata[referenceType]=referenceTypeF[1].getUsedFields()
                       
         return mo.getFieldList(),mo.getFields()  
                           bibdata['data']=referenceTypeF[1]
                           fields=bibdata[referenceType]
                           for field in fieldlist:
                               retdata[field]=referenceTypeF[1].getValue(field)[1]
           
           return retdata,fieldlist,temp,fields
   
     def findTagsFromMapping(self,referenceType):      def findTagsFromMapping(self,referenceType):
         """gib hash mit label -> generic zurueck"""          """gib hash mit label -> generic zurueck"""
                   
         return self.findLabelsFromMapping(referenceType)  
   
           if referenceType=="":
                   referenceType="book"
           
           temp =  self.ZopeFind(self.getStandardMD())[0:]
         
     def copyIndex_meta2echo_resource(self,RESPONSE=None):  
             #copy MD von Index_meta to the echo_resource  
                           
             logging.debug("copyIndex_meta2echo_resource:"+self.metalink)          #self.referencetypes=temp[0:]
             md = self.getMetaDataManager().getBibData(path=self.metalink)  
             logging.debug("copyIndex_meta2echo_resource:"+repr(md))  
             self.metaDataHash=self.getMetaDataManager().getBibMappedData(md)  
             logging.debug("copyIndex_meta2echo_resource:"+repr(self.metaDataHash))  
                           
             self.contentType=normalizeCt(self.metaDataHash.get('@type',''))  
                           
             return  
                         
     def getDRI(self,type="escidoc"):  
         """get DRI"""          bibdata={}
           retdata={}
           fieldlist=self.getStandardMD().fieldList
           fields=[]
           for referenceTypeF in temp:
                   #print referenceType
           
                   if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
         try:          try:
             dri = self.getMetaDataManager().getDRI(path=self.metalink,type=type)                                  bibdata[referenceTypeF[1].title]=referenceTypeF[1].getUsedFields()
                                   referenceType=referenceTypeF[1].title
         except:          except:
             return None                                  logging.debug("Error in ECHOresource(findTagsFromMapping): %s %s"%(sys.exc_info()[0],sys.exc_info()[1]))
                                   logging.debug(referenceTypeF)
                                   #TODO:CCCC
                                   bibdata[referenceType]=referenceTypeF[1].getUsedFields()
                           bibdata['data']=referenceTypeF[1]
                           fields=bibdata[referenceType]
                           for field in fieldlist:
                               retdata[field]=referenceTypeF[1].getValue(field)[0]
           
           return retdata,fieldlist,temp,fields
   
       
       security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination
       def copyIndex_meta2echo_resource(self,RESPONSE=None):
               """copy MD von Index_meta to the echo_resource"""
               
               (metadict, error)=readMetadata(self.metalink)
               logging.debug(metadict)
               
               self.metaDataHash={}
               if not error=="": #Fehler beim Auslesen des Metafiles
                       
                       return "ERROR:",error,self.absolute_url()
                   
         return dri              self.contentType=normalizeCt(metadict['bib_type'])[0:]
               fields=self.findTagsFromMapping(normalizeCt(self.contentType))
               
               #fields=self.findLabelsFromMapping(normalizeCt(self.contentType))
               for field in fields[1]:
                       
                       if self.isDefinedInThisSet(fields,field):
                               #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))
                               self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))
   
               
               
               if RESPONSE:
                       return RESPONSE.redirect('manage_main')
               
               return "OK:",self.absolute_url(),normalizeCt(self.contentType)
                   
     def ECHO_getResourceMD(self,template="yes",back=None,overwrite="no"):      def ECHO_getResourceMD(self,template="yes",back=None,overwrite="no"):
         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""          """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
         #(metadict, error)=readMetadata(self.metalink)          (metadict, error)=readMetadata(self.metalink)
         logging.debug("getMetaData:"+self.metalink)          logging.debug("METADICT:")
                   logging.debug(metadict)
         self.copyIndex_meta2echo_resource()  
         if back:          if back:
             self.REQUEST.SESSION['back']=back              self.REQUEST.SESSION['back']=back
   
           if not error=="": #Fehler beim Auslesen des Metafiles
                   return "ERROR:",error
           
         if (not self.contentType) or (overwrite=="yes"):          if (not self.contentType) or (overwrite=="yes"):
                 self.contentType=normalizeCt(normalizeCt(self.metaDataHash.get('@type','')).lower())                  self.contentType=normalizeCt(normalizeCt(metadict['bib_type']).lower())
                                   
         if not (normalizeCt(self.contentType).lower()==normalizeCt(self.contentType).lower()):          if not (normalizeCt(metadict['bib_type']).lower()==normalizeCt(self.contentType).lower()):
                 self.REQUEST.SESSION['contentStorage']=normalizeCt(self.contentType)                  self.REQUEST.SESSION['contentStorage']=normalizeCt(metadict['bib_type'])
                 self.REQUEST.SESSION['contentZope']=normalizeCt(self.contentType)                  self.REQUEST.SESSION['contentZope']=normalizeCt(self.contentType)
   
                 return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()                  return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
Line 998  class ECHO_resource(CatalogAware,Folder, Line 1409  class ECHO_resource(CatalogAware,Folder,
         #self.REQUEST.SESSION['metadict']=metadict          #self.REQUEST.SESSION['metadict']=metadict
                   
                   
           
   
           self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)
   
   
         if template=="yes":          if template=="yes":
                 #pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_resourceMD.zpt'),metadict=metadict).__of__(self)                  #pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_resourceMD.zpt'),metadict=metadict).__of__(self)
                 pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')                  pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')
                                   
                 return pt(metadict=self.metaDataHash)                  return pt(metadict=metadict)
   
                   
   
           
           
 #    def ECHO_getMD(self,item):      def ECHO_getMD(self,item):
 #        """Ausgabe der MD"""          """Ausgabe der MD"""
 #        return getattr(self,item)          return getattr(self,item)
   
     def checkPDF(self,path):      def checkRDF(self,path):
             """check if pdf in the path"""              """check if pdf in the path"""
             try:              try:
                     for fileName in os.listdir(path):                      for fileName in os.listdir(path):
Line 1026  class ECHO_resource(CatalogAware,Folder, Line 1442  class ECHO_resource(CatalogAware,Folder,
     security.declareProtected('View','index_html')      security.declareProtected('View','index_html')
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
         pdf=self.checkPDF(self.link)          pdf=self.checkRDF(self.link)
         if pdf:          if pdf:
                 fh=file(pdf,'r').read()                  fh=file(pdf,'r').read()
                 self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')                  self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')
Line 1068  class ECHO_resource(CatalogAware,Folder, Line 1484  class ECHO_resource(CatalogAware,Folder,
                     return sp[0][1]()                      return sp[0][1]()
   
   
     security.declarePublic('generate_label')       security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
   
     def generate_label(self):      def generate_label(self):
         """Erzeugt_standard_Label aus Template"""          """Erzeugt_standard_Label aus Template"""
         self.label=self.getMetaDataManager().getBibFormattedLabel(path=self.metalink)  
         return self.label  
                   
           templateName="label_template_"+normalizeCt(self.contentType).lower();
           if hasattr(self, templateName):
               pt=getattr(self,templateName)
               self.title=pt()[0:]
               return pt()
           else:
               pt=getattr(self.metadata,templateName)
               
               mdHash={}
               #mdHash={"author":self.getMDValue('author'),"title":self.getMDValue('title'),"year":self.MD_year}
               #logging.debug(mdHash)
               logging.debug("new format for template")
               fields=['author','title','year']
               
               for field in fields:
                   mdHash[field]=self.getMDValue(field);
                       
               # jetzt die spezifischen
               for field in self.getMetaDataHash().keys():
                       
                       if (not field is None) and (not (field in fields)):
   
                           logging.debug(field)
                           mdHash[field]=self.getMDValue(field);
       
               
               self.title=pt(md=mdHash)[0:]
               return pt(md=mdHash)[0:]
           
           
           
           
       security.declarePublic('generate_title') # has to be change, presently set because of OSAS koordination
   
     security.declarePublic('generate_title')   
     def generate_title(self,RESPONSE=None):      def generate_title(self,RESPONSE=None):
         """Erzeugt_standard_Label aus Template"""          """Erzeugt_standard_Label aus Template"""
         self.title=self.generate_label();          
         return self.title            
           templateName="label_template_"+normalizeCt(self.contentType).lower();
           if hasattr(self, templateName):
               pt=getattr(self,templateName)
               self.title=pt()[0:]
               return pt()
           else:
               pt=getattr(self.metadata,templateName)
               
               mdHash={}
               #mdHash={"author":self.getMDValue('author'),"title":self.getMDValue('title'),"year":self.MD_year}
               #logging.debug(mdHash)
               logging.debug("new format for template")
               fields=['author','title','year']
               
               for field in fields:
                   mdHash[field]=self.getMDValue(field);
                       
               # jetzt die spezifischen
               for field in self.getMetaDataHash().keys():
                       
                       if (not field is None) and (not (field in fields)):
   
                           logging.debug(field)
                           mdHash[field]=self.getMDValue(field);
       
               
               self.title=pt(md=mdHash)[0:]
               return pt(md=mdHash)[0:]
           
           
           
   
 Globals.InitializeClass(ECHO_resource)  Globals.InitializeClass(ECHO_resource)
   
Removed from v.1.6.2.5  
changed lines
  Added in v.1.9

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