[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.1 and 1.6.2.4

version 1.1, 2008/12/04 21:27:00 version 1.6.2.4, 2012/08/23 10:25:32
Line 1 Line 1
   #TODO: change metaDataHash, jetzt tag -> data(tags aus dem neuen Metadatamain)
   #TODO: erstes OSAS_meta ueberall durch self.metaDataHAst
   #TODO: contentType aus den Metadaten
   
 import urlparse  import urlparse
 import string  import string
 import tempfile  import tempfile
Line 23  from Globals import Persistent, package_ Line 27  from Globals import Persistent, package_
 from Acquisition import Implicit  from Acquisition import Implicit
 from Products.ZCatalog.CatalogPathAwareness import CatalogAware  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
 from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon  from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon
   try:
 from Products.MetaDataProvider.MetaDataClient import MetaDataClient  from Products.MetaDataProvider.MetaDataClient import MetaDataClient
   except:
       print "no metadata services"
 import urllib  import urllib
 import urllib2  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 55  from ECHO_helpers import * Line 62  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 68  class ECHO_resource(CatalogAware,Folder, Line 75  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 201  class ECHO_resource(CatalogAware,Folder, Line 221  class ECHO_resource(CatalogAware,Folder,
   
     def getRDF(self,urn=None):      def getRDF(self,urn=None):
             """rdf"""              """rdf"""
             ret=getRDFDescription(self,self.link,urn=urn)              ap = self.getArchivePathFromMetadata()
            
          
               ret=getRDFDescription(self,self.link,urn=urn,ap=ap)
              
             return ret+self.createSubElementRDF(urn=urn)               return ret+self.createSubElementRDF(urn=urn) 
   
       
Line 416  class ECHO_resource(CatalogAware,Folder, Line 440  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"""
   
                           
             resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')              resourcepath=readFieldFromXML_xpath(self.metalink,'//resource/archive-path')
                           
             digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')              digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')
             images=readFieldFromXML(self.metalink,'texttool','image')              images=readFieldFromXML(self.metalink,'texttool','image')
Line 448  class ECHO_resource(CatalogAware,Folder, Line 464  class ECHO_resource(CatalogAware,Folder,
     def copyTitleToInfoXML(self,RESPONSE=None):      def copyTitleToInfoXML(self,RESPONSE=None):
             """copy title from the resource"""              """copy title from the resource"""
             presentationXML=readFieldFromXML(self.metalink,'texttool','presentation')              presentationXML=readFieldFromXML(self.metalink,'texttool','presentation')
             resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')              resourcepath=readFieldFromXML_xpath(self.metalink,'//resource/archive-path')
             if (not presentationXML) or (not resourcepath):               if (not presentationXML) or (not resourcepath): 
                 if RESPONSE:                  if RESPONSE:
                         RESPONSE.write("Error: %s\n"%self.getId())                          RESPONSE.write("Error: %s\n"%self.getId())
Line 472  class ECHO_resource(CatalogAware,Folder, Line 488  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 550  class ECHO_resource(CatalogAware,Folder, Line 515  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 645  class ECHO_resource(CatalogAware,Folder, Line 568  class ECHO_resource(CatalogAware,Folder,
             """gibt pfad zum image aus"""              """gibt pfad zum image aus"""
             return self.getImageView(noredirect="yes",onlyPath="yes")              return self.getImageView(noredirect="yes",onlyPath="yes")
           
       def getArchivePathFromMetadata(self):
           try:
               archivePath=readFieldFromXML_xpath(self.metalink,"//resource/archive-path")
               return archivePath
           except:
               return ""
       
     def getImageView(self,noredirect=None,onlyPath=None):      def getImageView(self,noredirect=None,onlyPath=None):
             """getImages; give Imageviewr  and <error></error> if somthing goes wrong."""              """getImages; give Imageviewr  and <error></error> if somthing goes wrong."""
             try:              try:
                     fh=ECHO_helpers.urlopen(self.metalink)                      archivePath=readFieldFromXML_xpath(self.metalink,"//resource/archive-path")
                     dom=xml.dom.minidom.parse(fh)  
                     texttools=dom.getElementsByTagName('texttool')  
                     text=texttools[0].getElementsByTagName('image')  
                     imagetemp=getText(text[0].childNodes)  
                                           
                     text=dom.getElementsByTagName('archive-path')  
                     archivepath=getText(text[0].childNodes)  
                     archivepath=re.sub('/mpiwg/online/','',archivepath)                       archivepath=re.sub('/mpiwg/online/','',archivepath) 
                     imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp                      imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp
                     fh.close()                      fh.close()
Line 853  class ECHO_resource(CatalogAware,Folder, Line 777  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 978  class ECHO_resource(CatalogAware,Folder, Line 888  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 1015  class ECHO_resource(CatalogAware,Folder, Line 918  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('year',''),self.getTitle()])
                                           
                     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:"+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"""
             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')              self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
Line 1085  class ECHO_resource(CatalogAware,Folder, Line 939  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 1152  class ECHO_resource(CatalogAware,Folder, Line 1000  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  
   
           
   
     def getMetaDataHash(self):      def getMetaDataHash(self):
             """md hash"""              """md hash"""
             return self.metaDataHash  
           
     def setFieldValue(self,field,value):              return getattr(self,'metaDataHash',{})
         """get value"""  
         #TODO: remove setFieldValue  
                   
         if not hasattr(self,'metaDataHash'):      def getMetaDataValue(self,fieldName):
                 setattr(self,'metaDataHash',{})  
         self.metaDataHash[field]=value[0:]  
   
     def copySearchFields(self):  
             """copys metadatafields to the object"""  
             fields=['author','title','year']  
               
             for field in fields:  
                     setattr(self,'MD_'+field,self.getMDValue(field,generic="yes"))  
           
           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"  
                   
                   return mo.getFieldList(),mo.getFields()
         bibdata={}  
         retdata={}  
         fields=[]  
         fieldlist=self.standardMD.fieldList  
   
         tags=self.findTagsFromMapping(normalizeCt(self.contentType))  
         self.referencetypes=tags[2]  
         for referenceTypeF in self.referencetypes:  
                   
                   
                 if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):  
   
                         try:  
                                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields  
                                 referenceType=referenceTypeF[1].title  
                         except:  
                                 bibdata[referenceType]=referenceTypeF[1].fields  
                   
   
                         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.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:
                                 bibdata[referenceType]=referenceTypeF[1].fields              return None
                         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 1340  class ECHO_resource(CatalogAware,Folder, Line 1080  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 checkRDF(self,path):
             """check if pdf in the path"""              """check if pdf in the path"""
Line 1419  class ECHO_resource(CatalogAware,Folder, Line 1154  class ECHO_resource(CatalogAware,Folder,
   
     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') # has to be change, presentlyset because of OSAS koordination
   
     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.1  
changed lines
  Added in v.1.6.2.4

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