[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.4 and 1.9

version 1.6.2.4, 2012/08/23 10:25:32 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: 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 36  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 62  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 76  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 308  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 440  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 488  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 515  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 537  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 557  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 777  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 787  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 804  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 888  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 918  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"""
             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')              self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
Line 939  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 1000  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 1015  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"
           
                       
         return mo.getFieldList(),mo.getFields()          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()
                   
   
                           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()
               
               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),''))
   
                   
         return dri              
               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 1080  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 checkRDF(self,path):      def checkRDF(self,path):
             """check if pdf in the path"""              """check if pdf in the path"""
Line 1154  class ECHO_resource(CatalogAware,Folder, Line 1488  class ECHO_resource(CatalogAware,Folder,
   
     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, 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"""
         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.4  
changed lines
  Added in v.1.9

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