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

version 1.6.2.1, 2011/10/13 07:48:27 version 1.8, 2012/01/04 11:21:10
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 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.  
          """  
            
          return getattr(self,"metadata",None)  
   
     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 305  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 437  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 485  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):      def changeViewerTemplateSetForm(self):
             """change the viewer template set"""              """change the viewer template set"""
Line 516  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 538  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)
   
Line 778  class ECHO_resource(CatalogAware,Folder, Line 882  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 788  class ECHO_resource(CatalogAware,Folder, Line 906  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 805  class ECHO_resource(CatalogAware,Folder, Line 926  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 889  class ECHO_resource(CatalogAware,Folder, Line 1011  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 919  class ECHO_resource(CatalogAware,Folder, Line 1048  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:
                       
                       ret =self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%normalizeCt(self.contentType))
                   except:
                       logger("ECHO (line 1069)",logging.ERROR,"no md hash for %s"%self.getId()) 
                       return ""
                     
               else:
                           
                           
             bibdata=self.getMetaDataManager().getBibData(path=self.getMetaDataLink())                     ret= self.metaDataHash.get(fieldNameTest,empty)
             dcMapped = self.getMetaDataManager().getDCMappedData(bibdata)  
             logging.debug("getMDValueSimpleSearchField:"+ repr(dcMapped))  
             return " ".join([dcMapped.get('title',''),  
                              dcMapped.get('creator',''),  
                              dcMapped.get('year',''),self.getTitle()])  
                         
               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 938  class ECHO_resource(CatalogAware,Folder, Line 1118  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 999  class ECHO_resource(CatalogAware,Folder, Line 1185  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':'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 1234  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 [],{}       
                       
         return mo.getFieldList(),mo.getFields()          if referenceType=="":
                   referenceType="book"
           
           
           bibdata={}
           retdata={}
           fields=[]
           fieldlist=self.getStandardMD().fieldList
   
           tags=self.findTagsFromMapping(normalizeCt(self.contentType))
           logging.debug("ECHO_resource(findLabelsFromMapping)"+repr(tags))
           self.referencetypes=tags[2]
           for referenceTypeF in self.referencetypes:
                   
                   logging.debug("--- compare"+normalizeCt(referenceTypeF[1].title)+normalizeCt(referenceType.lower()))
                   if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
                           
                           try:
                                   bibdata[referenceTypeF[1].title]=referenceTypeF[1].getUsedFields()
                                   referenceType=referenceTypeF[1].title
                                   logging.debug("------fields:"+repr(bibdata[referenceTypeF[1].title]))
                           except:
                                   bibdata[referenceType]=referenceTypeF[1].getUsedFields()
                   
   
                           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:]
   
           
           #self.referencetypes=temp[0:]
         
           
       
   
           bibdata={}
           retdata={}
           fieldlist=self.getStandardMD().fieldList
           fields=[]
           for referenceTypeF in temp:
                   #print referenceType
           
                   if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
                           try:
                                   bibdata[referenceTypeF[1].title]=referenceTypeF[1].getUsedFields()
                                   referenceType=referenceTypeF[1].title
                           except:
                                   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):      def copyIndex_meta2echo_resource(self,RESPONSE=None):
             #copy MD von Index_meta to the echo_resource              """copy MD von Index_meta to the echo_resource"""
                           
             logging.debug("copyIndex_meta2echo_resource:"+self.metalink)              (metadict, error)=readMetadata(self.metalink)
             md = self.getMetaDataManager().getBibData(path=self.metalink)              logging.debug(metadict)
             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',''))              self.metaDataHash={}
               if not error=="": #Fehler beim Auslesen des Metafiles
                           
             return                      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)
                   
     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 1071  class ECHO_resource(CatalogAware,Folder, Line 1390  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 1145  class ECHO_resource(CatalogAware,Folder, Line 1469  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.1  
changed lines
  Added in v.1.8

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