[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.6 and 1.7

version 1.6.2.6, 2012/09/03 14:48:22 version 1.7, 2012/01/03 13:02:31
Line 1 Line 1
 #TODO: change metaDataHash, jetzt tag -> data(tags aus dem neuen Metadatamain)  
 #TODO: contentType aus den Metadaten  
   
 import urlparse  import urlparse
 import string  import string
 import tempfile  import tempfile
Line 35  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 61  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 74  class ECHO_resource(CatalogAware,Folder, Line 71  class ECHO_resource(CatalogAware,Folder,
           
     #    viewClassificationList=viewClassificationListMaster      #    viewClassificationList=viewClassificationListMaster
           
       
       
            
     def PrincipiaSearchSource(self):      def PrincipiaSearchSource(self):
            """Return cataloguable key for ourselves."""             """Return cataloguable key for ourselves."""
            return str(self)             return str(self)
                       
     def getDCDate(self):  
         """dc mapped date"""  
         try:  
             bibdata=self.getMetaDataManager().getBibData(path=self.getMetaDataLink())  
             dcMapped = self.getMetaDataManager().getDCMappedData(bibdata)  
             return dcMapped.get('date')  
         except:  
                
             logging.error("getDCDate doesn't work, cannot read metadata:"+self.getId())  
               
           
     getSubCols = ECHO_helpers.getSubCols      getSubCols = ECHO_helpers.getSubCols
           
 #    def getMetaDataManager(self):  
 #        """hole eine Instanz von MetaDataFolder  
 #        TODO: sollte konfigurierbar sein.   
 #        zur Zeit wird enfach nur self.metadata falls vorhanden zurueckggegeben.  
 #        """  
 #     
 #        mf= getattr(self,"metadataFolder",None)  
 #        #logging.debug("MetadataManager:"+repr(mf))  
 #        return mf  
 #          
   
     def index_meta(self,RESPONSE=None):      def index_meta(self,RESPONSE=None):
         """ gibt das im metalink gespeicher xml-file zurueck"""          """ gibt das im metalink gespeicher xml-file zurueck"""
         url = self.metalink          url = self.metalink
Line 147  class ECHO_resource(CatalogAware,Folder, Line 119  class ECHO_resource(CatalogAware,Folder,
         self.reindex_object()          self.reindex_object()
       
       
       security.declareProtected('View','createPDF')
       def createPDF(self,RESPONSE=None,local=None,dpi=150):
               """erzeuge pdf file"""
               pages=1
               dpi=float(dpi)
               imagePath=self.getImagePath().replace("/mpiwg/online","")
               
               
               image="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn="+imagePath+"&dw=%i&dh=%i&pn=%i"
               xmlInfo="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/dlInfo-xml.jsp?fn="+imagePath
   
               dom=xml.dom.minidom.parse(urllib.urlopen(xmlInfo))
               for parameter in dom.getElementsByTagName('parameter'):
                       if parameter.getAttribute('name')=="pt":
                               pages=int(parameter.getAttribute('value'))
                               break
               
   
               tempdir="/tmp/archivesImageServer"
               if not os.path.exists(tempdir):
                       os.mkdir(tempdir) 
     
               tmpPath=tempfile.mkdtemp(dir=tempdir)
               
   
               tmpZip=tempfile.mktemp(dir=tempdir)
   
               tmpFn=os.path.split(tmpZip)[1]
   
   
       
   
               if RESPONSE:
                       RESPONSE.setHeader("Content-Type","text/html")
                       RESPONSE.write("<h1>I am creating  the pdf</h1>")
                       txt="<h3>1. step: getting the images( %i pages)</h3>"%pages
                       RESPONSE.write(txt)
   
               c=canvas.Canvas(tmpZip)
               for i in range(1,pages+1):
                       if RESPONSE:
                               RESPONSE.write(str("<p>Get Page: %i<br>\n"%i))
                       faktor=dpi/72.0
                       
                       fn=tmpPath+"/%i"%i
   
                       width,height=A4
                       #print image%(width*faktor,height*faktor,i)
                       url=urllib.urlopen(image%(width*faktor,height*faktor,i)).read()
                       fh=file(fn,"w")
                       fh.write(url)
                       fh.close()
   
       
   
                       c.drawImage(fn,0,0,width=width,height=height)
                       c.showPage()
               c.save()
               if RESPONSE:
                       RESPONSE.write("<p>finished<br>\n")
   
               if RESPONSE:
                       len=os.stat(tmpZip)[6]
                       downloadUrl=self.absolute_url()+"/downloadPDF"
                       RESPONSE.write("""<h1><a href="downloadPDF?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))
                       RESPONSE.write("""<p>The file will be stored for a while, you can download it later, the URL is:</p>
                       <p><a href="downloadPDF?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn))
                       RESPONSE.close()
   
   
       def downloadPDF(self,fn):
               """download prepared set"""
               filename="/tmp/archivesImageServer/"+fn
               namePDF=self.getId()+".pdf"
               self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%namePDF)
               self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
               len=os.stat(filename)[6]
               self.REQUEST.RESPONSE.setHeader("Content-Length",len)
               images=file(filename).read()
               self.REQUEST.RESPONSE.write(images)
               self.REQUEST.RESPONSE.close()
     
   
     def getRDF(self,urn=None):      def getRDF(self,urn=None):
Line 370  class ECHO_resource(CatalogAware,Folder, Line 423  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 418  class ECHO_resource(CatalogAware,Folder, Line 479  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 445  class ECHO_resource(CatalogAware,Folder, Line 557  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 467  class ECHO_resource(CatalogAware,Folder, Line 621  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 605  class ECHO_resource(CatalogAware,Folder, Line 773  class ECHO_resource(CatalogAware,Folder,
             return []              return []
   
   
 #    def getStorageManagerResourceURL(self):      def getStorageManagerResourceURL(self):
 #        """get the link to storage"""          """get the link to storage"""
 #        urlbase=self.getStorageManagerURL();          urlbase=self.getStorageManagerURL();
 #                  
 #        #now get the path from the metadatalink          #now get the path from the metadatalink
 #                  
 #        path = self.correctPath(self.getMetaDataLink())          path = self.correctPath(self.getMetaDataLink())
 #        if path is None:          if path is None:
 #            return ""              return ""
 #        else:          else:
 #            path=path.replace("index.meta","")              path=path.replace("index.meta","")
 #            return urlbase+path              return urlbase+path
 #                  
                   
     def correctPath(self,path):      def correctPath(self,path):
         #take only the path of the url which starts with /permanent or /experimental          #take only the path of the url which starts with /permanent or /experimental
Line 707  class ECHO_resource(CatalogAware,Folder, Line 875  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 818  class ECHO_resource(CatalogAware,Folder, Line 1000  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 848  class ECHO_resource(CatalogAware,Folder, Line 1037  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:              try:
                 bibdata=self.getMetaDataManager().getBibData(path=self.getMetaDataLink())                  return " ".join([self.getMDValue('title',generic="yes"),
                 dcMapped = self.getMetaDataManager().getDCMappedData(bibdata)                               self.getMDValue('author',generic="yes"),
                 logging.debug("getMDValueSimpleSearchField:"+ repr(dcMapped))                               self.getMDValue('year',generic="yes"),self.getTitle()])
                 return " ".join([dcMapped.get('title',''),              except:
                              dcMapped.get('creator',''),                  
                              dcMapped.get('date',''),self.getTitle(),self.getDescription()])                  #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:              except:
                 logging.error("getMDValueSimpleSearchField doesn't work cannot read metadata:"+self.getId())                      logger("ECHO (line 1069)",logging.ERROR,"no md hash for %s"%self.getId()) 
                 return " ".join([self.getDescription(),self.getTitle()])                      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"""
Line 870  class ECHO_resource(CatalogAware,Folder, Line 1107  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 931  class ECHO_resource(CatalogAware,Folder, Line 1174  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 946  class ECHO_resource(CatalogAware,Folder, Line 1223  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"
           
           
           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()
                   
                       
         return mo.getFieldList(),mo.getFields()                          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"):          bibdata={}
         """get DRI"""          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))
                   
         return dri              #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 1011  class ECHO_resource(CatalogAware,Folder, Line 1379  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 checkPDF(self,path):      def checkRDF(self,path):
             """check if pdf in the path"""              """check if pdf in the path"""
             try:              try:
                     for fileName in os.listdir(path):                      for fileName in os.listdir(path):
Line 1039  class ECHO_resource(CatalogAware,Folder, Line 1412  class ECHO_resource(CatalogAware,Folder,
     security.declareProtected('View','index_html')      security.declareProtected('View','index_html')
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
         pdf=self.checkPDF(self.link)          pdf=self.checkRDF(self.link)
         if pdf:          if pdf:
                 fh=file(pdf,'r').read()                  fh=file(pdf,'r').read()
                 self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')                  self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')
Line 1081  class ECHO_resource(CatalogAware,Folder, Line 1454  class ECHO_resource(CatalogAware,Folder,
                     return sp[0][1]()                      return sp[0][1]()
   
   
     security.declarePublic('generate_label')       security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
   
     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, presently set because of OSAS koordination
   
     security.declarePublic('generate_title')   
     def generate_title(self,RESPONSE=None):      def generate_title(self,RESPONSE=None):
         """Erzeugt_standard_Label aus Template"""          """Erzeugt_standard_Label aus Template"""
         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.6  
changed lines
  Added in v.1.7

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