[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 and 1.6.2.6

version 1.6, 2010/10/11 13:14:59 version 1.6.2.6, 2012/09/03 14:48:22
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 32  import urllib2 Line 35  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 58  from ECHO_helpers import * Line 61  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 71  class ECHO_resource(CatalogAware,Folder, Line 74  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)
   
       def getDCDate(self):
           """dc mapped date"""
           try:
               bibdata=self.getMetaDataManager().getBibData(path=self.getMetaDataLink())
               dcMapped = self.getMetaDataManager().getDCMappedData(bibdata)
               return dcMapped.get('date')
           except:
                
               logging.error("getDCDate doesn't work, cannot read metadata:"+self.getId())
               
           
     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 119  class ECHO_resource(CatalogAware,Folder, Line 147  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 423  class ECHO_resource(CatalogAware,Folder, Line 370  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 479  class ECHO_resource(CatalogAware,Folder, Line 418  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 557  class ECHO_resource(CatalogAware,Folder, Line 445  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 759  class ECHO_resource(CatalogAware,Folder, Line 605  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 861  class ECHO_resource(CatalogAware,Folder, Line 707  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 986  class ECHO_resource(CatalogAware,Folder, Line 818  class ECHO_resource(CatalogAware,Folder,
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def changeECHO_resource_metadata_local(self,RESPONSE=None):  
             """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:]  
                                                   
       def changeECHO_resource_metadata(self,RESPONSE=None):
               """change metadata"""
   
               self.copyIndex_meta2echo_resource()
               tags=mappedData.keys()
                                           
             if RESPONSE is not None:  
                     RESPONSE.redirect('manage_main')  
   
     def changeECHO_resource_metadata(self,RESPONSE=None):              for field in tags:
             """change metadata"""  
             tags=self.findTagsFromMapping(normalizeCt(self.contentType))  
             self.OSAS_meta={}  
             for field in tags[1]:  
                     try:                      try:
                             self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]                              self.metaDataHash[field]=self.REQUEST.form[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 1023  class ECHO_resource(CatalogAware,Folder, Line 848  class ECHO_resource(CatalogAware,Folder,
           
   
     def getMDValueSimpleSearchField(self):      def getMDValueSimpleSearchField(self):
             """returns value for simple search"""              """returns value for simple search aus DC daten"""
               
             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.standardMD,ct):      
                     fieldName=getattr(self.standardMD,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('date',''),self.getTitle(),self.getDescription()])
                                           
                     ret =self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%normalizeCt(self.contentType))  
                 except:                  except:
                     logger("ECHO (line 1069)",logging.ERROR,"no md hash for %s"%self.getId())                   logging.error("getMDValueSimpleSearchField doesn't work cannot read metadata:"+self.getId())
                     return ""                  return " ".join([self.getDescription(),self.getTitle()])
                                       
             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 1093  class ECHO_resource(CatalogAware,Folder, Line 870  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 1160  class ECHO_resource(CatalogAware,Folder, Line 931  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':'Change Local Metadata','action':'ECHO_resource_config_metadata'},          {'label':'Edit Metadata','action':'ECHO_getResourceMD'},
         {'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 1209  class ECHO_resource(CatalogAware,Folder, Line 946  class ECHO_resource(CatalogAware,Folder,
                         
             return getattr(self,'metaDataHash',{})              return getattr(self,'metaDataHash',{})
           
     def setFieldValue(self,field,value):      def getMetaDataValue(self,fieldName):
         """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 in fields):  
                         logging.debug("ECHO_resource (copySearchFields) mapping: "+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)
   
         temp=self.ZopeFind(self.standardMD)          if mo is None:
               return [],{}     
         if referenceType=="":  
                 referenceType="book"  
           
           
         bibdata={}  
         retdata={}  
         fields=[]  
         fieldlist=self.standardMD.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].fields  
                                 referenceType=referenceTypeF[1].title  
                                 logging.debug("------fields:"+repr(fields))  
                         except:  
                                 bibdata[referenceType]=referenceTypeF[1].fields  
                   
   
                         bibdata['data']=referenceTypeF[1]          return mo.getFieldList(),mo.getFields()
                         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.standardMD)[0:]  
   
                   
         #self.referencetypes=temp[0:]  
                   
       def copyIndex_meta2echo_resource(self,RESPONSE=None):
               #copy MD von Index_meta to the echo_resource
                   
               logging.debug("copyIndex_meta2echo_resource:"+self.metalink)
               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',''))
   
         bibdata={}              return
         retdata={}  
         fieldlist=self.standardMD.fieldList  
         fields=[]  
         for referenceTypeF in temp:  
                 #print referenceType  
                   
                 if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):      def getDRI(self,type="escidoc"):
           """get DRI"""
                         try:                          try:
                                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields              dri = self.getMetaDataManager().getDRI(path=self.metalink,type=type)
                                 referenceType=referenceTypeF[1].title  
                         except:                          except:
                                 logging.debug("Error in ECHOresource(findTagsFromMapping): %s %s"%(sys.exc_info[0],sys.exc_info[1]))              return None
                                 bibdata[referenceType]=referenceTypeF[1].fields  
                         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)  
   
   
               
             self.metaDataHash={}  
             if not error=="": #Fehler beim Auslesen des Metafiles  
                       
                     return "ERROR:",error,self.absolute_url()  
               
             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)          return dri
                   
     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)
               
           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(metadict['bib_type']).lower())                  self.contentType=normalizeCt(normalizeCt(self.metaDataHash.get('@type','')).lower())
                                   
         if not (normalizeCt(metadict['bib_type']).lower()==normalizeCt(self.contentType).lower()):          if not (normalizeCt(self.contentType).lower()==normalizeCt(self.contentType).lower()):
                 self.REQUEST.SESSION['contentStorage']=normalizeCt(metadict['bib_type'])                  self.REQUEST.SESSION['contentStorage']=normalizeCt(self.contentType)
                 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 1361  class ECHO_resource(CatalogAware,Folder, Line 1011  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=metadict)                  return pt(metadict=self.metaDataHash)
   
                   
   
           
           
     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 checkRDF(self,path):      def checkPDF(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 1394  class ECHO_resource(CatalogAware,Folder, Line 1039  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.checkRDF(self.link)          pdf=self.checkPDF(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 1436  class ECHO_resource(CatalogAware,Folder, Line 1081  class ECHO_resource(CatalogAware,Folder,
                     return sp[0][1]()                      return sp[0][1]()
   
   
     security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination      security.declarePublic('generate_label') 
   
     def generate_label(self):      def generate_label(self):
         """Erzeugt_standard_Label aus Template"""          """Erzeugt_standard_Label aus Template"""
         pt=getattr(self,"label_template_"+normalizeCt(self.contentType).lower())          self.label=self.getMetaDataManager().getBibFormattedLabel(path=self.metalink)
           return self.label
         self.label=pt()[0:]  
         return pt()  
   
     security.declarePublic('generate_title') # has to be change, presentlyset 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"""
         pt=getattr(self,"label_template_"+normalizeCt(self.contentType).lower())          self.title=self.generate_label();
           return self.title
         self.title=pt()[0:]  
           
         return pt()  
   
 Globals.InitializeClass(ECHO_resource)  Globals.InitializeClass(ECHO_resource)
   
Removed from v.1.6  
changed lines
  Added in v.1.6.2.6

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