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

Diff for /ECHO_content/ECHO_resource.py between versions 1.6 and 1.6.2.2

version 1.6, 2010/10/11 13:14:59 version 1.6.2.2, 2012/01/04 08:41:37
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 32  import urllib2 Line 36  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 71  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.
            """
            
            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 423  class ECHO_resource(CatalogAware,Folder, Line 437  class ECHO_resource(CatalogAware,Folder,
                     
                 server.writeMetaDataFile(path,string,"yes")                  server.writeMetaDataFile(path,string,"yes")
                   
     def setStartPageForm(self):  
             """Form for changing the startpage"""  
   
               
             pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPage.zpt')  
             pt.content_type="text/html"  
             return pt()  
       
   
     def createImageUrl(self,pn=1):      def createImageUrl(self,pn=1):
             """create ImageUrl"""              """create ImageUrl"""
Line 479  class ECHO_resource(CatalogAware,Folder, Line 485  class ECHO_resource(CatalogAware,Folder,
                             return None,self.absolute_url()                              return None,self.absolute_url()
   
                           
     def setStartPage(self,startpage=None,RESPONSE=None):  
             """set start page, if no startpage defined use the generic one of the resource"""  
   
             if (not (type(startpage)==StringType)):  
                     if ("__generic" in startpage): # checke ob generic in der liste  
                             startpage=self.absolute_url()+"/startpage_html"  
                     elif ("__firstPage" in startpage): # checke ob generic in der liste  
                             startpage=self.createImageUrl()  
                               
             if (not startpage):  
                     startpage=self.absolute_url()+"/startpage_html"  
             elif (startpage=="__generic"):  
                     startpage=self.absolute_url()+"/startpage_html"  
             elif (startpage=="__firstPage"):  
                         startpage=self.createImageUrl()  
       
             params="startpage=%s"%startpage  
             #print 'http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))  
                  
             tries=0  
             for i in range(10):  
                     x=ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()  
                     if x=="ok":  
                              
                             break;  
                    
               
             path=self.metalink  
               
             path=re.sub(self.REQUEST['SERVER_URL'],'',path)  
             path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)  
               
             path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server  
             path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server  
             path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server  
             path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server  
             path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server  
             path=re.sub('http://vision.mpiwg-berlin.mpg.de','',path) # falls vision als server  
             path=re.sub('http://xserve02.mpiwg-berlin.mpg.de:18880','',path) # falls vision als server  
             path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo  
             path=re.sub('/index.meta','',path)   
   
   
             ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()  
   
             if RESPONSE is not None:  
                         RESPONSE.redirect('manage_main')  
   
     def changeViewerTemplateSetForm(self):  
             """change the viewer template set"""  
             pt=zptFile(self, 'zpt/changeResourceViewerTemplateSet')  
             return pt()  
   
   
     def setLink(self, link=None):      def setLink(self, link=None):
Line 557  class ECHO_resource(CatalogAware,Folder, Line 512  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 861  class ECHO_resource(CatalogAware,Folder, Line 774  class ECHO_resource(CatalogAware,Folder,
         pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')          pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')
         return pt()          return pt()
   
     def ECHO_resource_config_metadata(self):  
         """Main configuration"""  
         if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):  
                 self.metaDataHash={}  
                 self.contentType=self.bib_type  
                 for data in self.metadata:  
                         data_neu=re.sub('-','_',data)  
                         self.metaDataHash[data_neu]=getattr(self,data)[0:]  
   
           
         pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')  
         return pt()  
   
   
           
     def changeViewer(self,newViewer):      def changeViewer(self,newViewer):
         """set newViewer to the url of the new viewer          """set newViewer to the url of the new viewer
Line 986  class ECHO_resource(CatalogAware,Folder, Line 885  class ECHO_resource(CatalogAware,Folder,
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def changeECHO_resource_metadata_local(self,RESPONSE=None):  
             """change metadata"""  
             tags=self.findTagsFromMapping(normalizeCt(self.contentType))  
             for field in tags[1]:  
                     self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]  
                                                   
       def changeECHO_resource_metadata(self,RESPONSE=None):
               """change metadata"""
   
               self.copyIndex_meta2echo_resource()
               tags=mappedData.keys()
                                           
             if RESPONSE is not None:  
                     RESPONSE.redirect('manage_main')  
   
     def changeECHO_resource_metadata(self,RESPONSE=None):              for field in tags:
             """change metadata"""  
             tags=self.findTagsFromMapping(normalizeCt(self.contentType))  
             self.OSAS_meta={}  
             for field in tags[1]:  
                     try:                      try:
                             self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]                              self.metaDataHash[field]=self.REQUEST.form[field]
                             self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]                      
                     except:                      except:
                             logger("ECHO_collection (changeECHO_resource_metadata)",logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])                              logger("ECHO_collection (changeECHO_resource_metadata)",logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])
   
Line 1023  class ECHO_resource(CatalogAware,Folder, Line 915  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):              bibdata=self.getMetaDataManager().getBibData(path=self.getMetaDataLink())
             """get md values"""              dcMapped = self.getMetaDataManager().getDCMappedData(bibdata)
             #TODO: cache mappinghash              logging.debug("getMDValueSimpleSearchField:"+ repr(dcMapped))
                           return " ".join([dcMapped.get('title',''),
             fieldName=None                               dcMapped.get('creator',''),
             if generic:                               dcMapped.get('year',''),self.getTitle()])
                 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:  
                       
                     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:  
   
                      
                    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 1093  class ECHO_resource(CatalogAware,Folder, Line 934  class ECHO_resource(CatalogAware,Folder,
             if not hasattr(self,'metaDataHash'):              if not hasattr(self,'metaDataHash'):
                                   
                     self.copyIndex_meta2echo_resource()                      self.copyIndex_meta2echo_resource()
             try:  
   
   
                     return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)  
             except:  
                     #print self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix  
   
                     return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)                      return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
   
Line 1160  class ECHO_resource(CatalogAware,Folder, Line 995  class ECHO_resource(CatalogAware,Folder,
                           
     manage_options = (      manage_options = (
         {'label':'Main Config','action':'ECHO_resource_config_main'},          {'label':'Main Config','action':'ECHO_resource_config_main'},
         {'label':'Change Local Metadata','action':'ECHO_resource_config_metadata'},          {'label':'Edit Metadata','action':'ECHO_getResourceMD'},
         {'label':'Sync Metadata with Repository','action':'ECHO_getResourceMD'},  
         {'label':'Graphic Coords','action':'ECHO_graphicEntry'},          {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
         {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},  
         {'label':'set/change startpage','action':'setStartPageForm'},          {'label':'set/change startpage','action':'setStartPageForm'},
         {'label':'Copy MD for indexing and search','action':'copySearchFields'},  
         {'label':'Change AccessRights','action':'changeAccessRightForm'},           {'label':'Change AccessRights','action':'changeAccessRightForm'}, 
         ) + Folder.manage_options          ) + Folder.manage_options
   
   
     def isDefinedInThisSet(self,fields,field):  
             """checks if field is defined in fields"""  
             if (fields[0].has_key(field)) and not (fields[0][field]==""):  
                     return 1  
             else:  
                     
                     return 0  
               
     def getFieldLabel(self,fields,field):  
         """get labels"""  
         try:  
             ret =fields[0][field]  
             if ret == "":  
                 return field  
             else:  
                 return ret  
         except:  
             return field  
   
   
   
     def getFieldTag(self,fields,field):  
         """get labels"""  
         try:  
             ret =fields[0][field]  
             if ret == "":  
                 return field  
             else:  
                 return ret  
         except:  
             return field  
   
           
   
Line 1209  class ECHO_resource(CatalogAware,Folder, Line 1010  class ECHO_resource(CatalogAware,Folder,
                         
             return getattr(self,'metaDataHash',{})              return getattr(self,'metaDataHash',{})
           
     def setFieldValue(self,field,value):      def getMetaDataValue(self,fieldName):
         """get value"""  
         #TODO: remove setFieldValue  
           
         if not hasattr(self,'metaDataHash'):  
                 setattr(self,'metaDataHash',{})  
         self.metaDataHash[field]=value[0:]  
   
     def copySearchFields(self):  
             """copys metadatafields to the object"""  
               
             # Zunaechst die gnerischen felder  
             fields=['author','title','year']  
             for field in fields:  
                 setattr(self,'MD_'+field,self.getMDValue(field,generic="yes"))  
                       
             # jetzt die spezifischen  
             for field in self.getMetaDataHash().keys():  
                     if not (field in fields):  
                         logging.debug("ECHO_resource (copySearchFields) mapping: "+field)  
                         setattr(self,'MD_'+field,self.getMDValue(field))  
       
               
                               
           self.copyIndex_meta2echo_resource()
           return self.metaDataHash.get(fieldName,{}).get('value','')
   
     def findLabelsFromMapping(self,referenceType):      def findLabelsFromMapping(self,referenceType):
         """gib hash mit label -> generic zurueck"""          """gib hash mit label -> generic zurueck"""
         #return {},[]          #return {},[]
           mo=self.getMetaDataManager().getBibMapping(referenceType)
   
         temp=self.ZopeFind(self.standardMD)          if mo is None:
               return [],{}     
         if referenceType=="":  
                 referenceType="book"  
           
           
         bibdata={}  
         retdata={}  
         fields=[]  
         fieldlist=self.standardMD.fieldList  
   
         tags=self.findTagsFromMapping(normalizeCt(self.contentType))          return mo.getFieldList(),mo.getFields()
         logging.debug("ECHO_resource(findLabelsFromMapping)"+repr(tags))  
         self.referencetypes=tags[2]  
         for referenceTypeF in self.referencetypes:  
                   
                 logging.debug("--- compare"+normalizeCt(referenceTypeF[1].title)+normalizeCt(referenceType.lower()))  
                 if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):  
                           
                         try:  
                                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields  
                                 referenceType=referenceTypeF[1].title  
                                 logging.debug("------fields:"+repr(fields))  
                         except:  
                                 bibdata[referenceType]=referenceTypeF[1].fields  
                   
   
                         bibdata['data']=referenceTypeF[1]  
                         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:]  
                   
                   
       
   
         bibdata={}  
         retdata={}  
         fieldlist=self.standardMD.fieldList  
         fields=[]  
         for referenceTypeF in temp:  
                 #print referenceType  
           
                 if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):  
                         try:  
                                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields  
                                 referenceType=referenceTypeF[1].title  
                         except:  
                                 logging.debug("Error in ECHOresource(findTagsFromMapping): %s %s"%(sys.exc_info[0],sys.exc_info[1]))  
                                 bibdata[referenceType]=referenceTypeF[1].fields  
                         bibdata['data']=referenceTypeF[1]  
                         fields=bibdata[referenceType]  
                         for field in fieldlist:  
                             retdata[field]=referenceTypeF[1].getValue(field)[0]  
           
         return retdata,fieldlist,temp,fields  
   
       
     security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination  
     def copyIndex_meta2echo_resource(self,RESPONSE=None):      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
               
             (metadict, error)=readMetadata(self.metalink)  
   
   
               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.metaDataHash={}              self.contentType=normalizeCt(self.metaDataHash.get('@type',''))
             if not error=="": #Fehler beim Auslesen des Metafiles  
                                           
                     return "ERROR:",error,self.absolute_url()              return
               
             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)
               
           self.copyIndex_meta2echo_resource()
         if back:          if back:
             self.REQUEST.SESSION['back']=back              self.REQUEST.SESSION['back']=back
   
         if not error=="": #Fehler beim Auslesen des Metafiles  
                 return "ERROR:",error  
           
         if (not self.contentType) or (overwrite=="yes"):          if (not self.contentType) or (overwrite=="yes"):
                 self.contentType=normalizeCt(normalizeCt(metadict['bib_type']).lower())                  self.contentType=normalizeCt(normalizeCt(self.metaDataHash.get('@type','')).lower())
                                   
         if not (normalizeCt(metadict['bib_type']).lower()==normalizeCt(self.contentType).lower()):          if not (normalizeCt(self.contentType).lower()==normalizeCt(self.contentType).lower()):
                 self.REQUEST.SESSION['contentStorage']=normalizeCt(metadict['bib_type'])                  self.REQUEST.SESSION['contentStorage']=normalizeCt(self.contentType)
                 self.REQUEST.SESSION['contentZope']=normalizeCt(self.contentType)                  self.REQUEST.SESSION['contentZope']=normalizeCt(self.contentType)
   
                 return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()                  return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
Line 1361  class ECHO_resource(CatalogAware,Folder, Line 1066  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 1440  class ECHO_resource(CatalogAware,Folder, Line 1140  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.6  
changed lines
  Added in v.1.6.2.2

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