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

Diff for /ECHO_content/ECHO_collection.py between versions 1.227 and 1.253

version 1.227, 2005/06/22 20:09:38 version 1.253, 2005/11/11 15:41:26
Line 37  from Products.PageTemplates.PageTemplate Line 37  from Products.PageTemplates.PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Globals import Persistent, package_home  from Globals import Persistent, package_home
 from Acquisition import Implicit  from Acquisition import Implicit
   from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   
 import urllib  import urllib
 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  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
Line 66  import ECHO_helpers Line 67  import ECHO_helpers
 from ECHO_helpers import *  from ECHO_helpers import *
 from ECHO_language import *  from ECHO_language import *
 from ECHO_movie import *  from ECHO_movie import *
   import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
 #regexp for extracting elements from xml  
 patternTXT=r"<\s*txt.*?>(.*?)</txt>"  
 regexpTXT = re.compile(patternTXT, re.IGNORECASE + re.DOTALL)  
 patternPage=r"<\s*page.*?>(.*?)</page>"  
 regexpPage = re.compile(patternPage, re.IGNORECASE + re.DOTALL)  
   
                   
   
Line 87  def setECHO_collectionInformation(self,t Line 83  def setECHO_collectionInformation(self,t
         self.credits=toList(credits)          self.credits=toList(credits)
         self.weight=weight          self.weight=weight
   
   class ECHO_locale(ZopePageTemplate):
           """localisierung"""
   
           meta_type="ECHO_locale"
   
           def __init__(self,id,lang,title,label,text=None,content_type=None):
                   self.lang=lang
                   self.title=title
                   self.label=label
                   if text:
                           self.pt_edit(text, content_type)
                   self.id=id
   
           manage_options = ZopePageTemplate.manage_options+(
                   {'label':'Main Config','action':'change_ECHO_localeForm'},
                   )
   
           def change_ECHO_localeForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_localeForm.zpt')
                   return pt()
           
           def change_ECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
                   """change echo locale"""
                   self.lang=lang
                   self.title=title
                   self.label=label
                   if not text is None:
                           self.pt_edit(text, content_type)
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
                   
   def manage_addECHO_localeForm(self):
            """Form for adding"""
            pt=zptFile(self, 'zpt/AddECHO_localeForm.zpt')
            return pt()
   
   def manage_addECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
           """add echo locale"""
   
           id="locale_"+lang
           
           self._setObject(id, ECHO_locale(id,lang,title,label,text,content_type))
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
   
                           
 class ECHO_copyright(Folder,ECHO_basis):  class ECHO_copyright(Folder,ECHO_basis):
     """Copyright informationen"""      """Copyright informationen"""
Line 254  def manage_addECHO_fullText(self, id, ti Line 298  def manage_addECHO_fullText(self, id, ti
     return ''      return ''
   
   
 class ECHO_resource(Folder,Persistent,ECHO_basis):  class ECHO_resource(CatalogAware,Folder,Persistent,ECHO_basis):
     """ECHO Ressource"""      """ECHO Ressource"""
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type='ECHO_resource'      meta_type='ECHO_resource'
       default_catalog='resourceCatalog'
   
 #    viewClassificationList=viewClassificationListMaster  #    viewClassificationList=viewClassificationListMaster
   
       def PrincipiaSearchSource(self):
              """Return cataloguable key for ourselves."""
              return str(self)
   
     getSubCols = ECHO_helpers.getSubCols      getSubCols = ECHO_helpers.getSubCols
   
       def reindex(self):
           """generate fields for indexing and reindex"""
           import urlparse
           #TODO: korrigieren des metalink pfades konfigurierbar machen
           splitted= [x for x in urlparse.urlparse(self.metalink)]
           splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]
           
           if splitted[0]=="http":
               self.metalink=urlparse.urlunparse(splitted)
           
   
           self.fullTextUrl=self.getFullTextXML(noredirect="yes")
           
           #TODO: korrigieren relative url to absoluter url volltexten, konfigurierbar?
           splitted= [x for x in urlparse.urlparse(self.fullTextUrl)]
           if splitted[0]=="":
               splitted[0]="http"
               splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]
               
               self.fullTextUrl=urlparse.urlunparse(splitted)
               
           self.imagePath=self.getImagePath()
           
           self.reindex_object()
     
       
     security.declareProtected('View','createPDF')      security.declareProtected('View','createPDF')
     def createPDF(self,RESPONSE=None,local=None,dpi=150):      def createPDF(self,RESPONSE=None,local=None,dpi=150):
Line 872  class ECHO_resource(Folder,Persistent,EC Line 946  class ECHO_resource(Folder,Persistent,EC
         self.contentType=self.bib_type          self.contentType=self.bib_type
         for data in self.metadata:          for data in self.metadata:
             data_neu=re.sub('-','_',data)              data_neu=re.sub('-','_',data)
             self.meta                          self.metaDataHash[data_neu]=getattr(self,data)[0:]
                         DataHash[data_neu]=getattr(self,data)[0:]  
   
           
         pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')          pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')
Line 965  class ECHO_resource(Folder,Persistent,EC Line 1038  class ECHO_resource(Folder,Persistent,EC
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def getMDValue(self,fieldName,empty=None):  
   
       def getMDValue(self,fieldNameTest,empty=None,generic=None):
               """get md values"""
               #TODO: cache mappinghash
               
               fieldName=None
               if generic:
                   ct=self.contentType.replace(" ","_").lower()
                   
                   #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:          if not empty:
                  #FIXME: warum gibt es manchmal kein metadatahas
                   try:
             return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)              return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)
                   except:
                       zLOG.LOG("ECHO (line 1069)",zLOG.ERROR,"no md hash for %s"%self.getId()) 
                       return ""
                   
         else:          else:
             return self.metaDataHash.get(fieldName,empty)  
                   return self.metaDataHash.get(fieldNameTest,empty)
   
       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 985  class ECHO_resource(Folder,Persistent,EC Line 1091  class ECHO_resource(Folder,Persistent,EC
             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)
   
     def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):      def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
         """schreibe md"""              """return bibliographical metadata as stored in the object"""
                   
         try:          try:
                           
Line 993  class ECHO_resource(Folder,Persistent,EC Line 1099  class ECHO_resource(Folder,Persistent,EC
         except:          except:
             return "<error> no metadata stored</error>"              return "<error> no metadata stored</error>"
           
       def getXQueryMetaData(self,xquery):
                   '''
                   execute an xquery on the metadata and returns a list of tuples, 
                   each tuple represent the content of the node as text and the whole node as xml-fragment
                   @param xquery: xquery auf den metadaten
                   '''
                   
                   try:
                           md=writeMetadata(self.metalink,self.metaDataHash,xmlfrag="yes")
                   except:
                           return None
   
                   dom = NonvalidatingReader.parseString(md,"http://www.mpiwg-berlin.mpg.de/")
                   
                   results=Ft.Xml.XPath.Evaluate(xquery, contextNode=dom)
               
                   ret=[]
                   for result in results:
                       
                       buf = cStringIO.StringIO()
                       PrettyPrint(result, stream=buf)
                       str = buf.getvalue()[0:]
                       buf.close()
                       ret.append((getTextFromNode(result),str)) 
                           
                   return ret
           
     def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):      def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
         """prints out metadata as stored in the echo environment, format is the index.meta format"""          """prints out metadata as stored in the echo environment, format is the index.meta format"""
         self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')          self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
Line 1054  class ECHO_resource(Folder,Persistent,EC Line 1187  class ECHO_resource(Folder,Persistent,EC
   
           
                   
     def getFieldValue(self,field):  
         """get value"""  
       
         try:  
       
             ret=self.metaDataHash[field]  
             if ret == "":  
                 return None  
             else:  
               
             return ret  
         except:  
             return None  
   
     def getMetaDataHash(self):      def getMetaDataHash(self):
         """md hash"""          """md hash"""
         return self.metaDataHash          return self.metaDataHash
           
     def setFieldValue(self,field,value):      def setFieldValue(self,field,value):
         """get value"""          """get value"""
           #TODO: remove setFieldValue
           
     if not hasattr(self,'metaDataHash'):      if not hasattr(self,'metaDataHash'):
         setattr(self,'metaDataHash',{})          setattr(self,'metaDataHash',{})
Line 1083  class ECHO_resource(Folder,Persistent,EC Line 1203  class ECHO_resource(Folder,Persistent,EC
     def copySearchFields(self):      def copySearchFields(self):
         """copys metadatafields to the object"""          """copys metadatafields to the object"""
         fields=['author','title','year']          fields=['author','title','year']
               
         for field in fields:          for field in fields:
             setattr(self,'MD_'+field,self.getFieldValue(field))                      setattr(self,'MD_'+field,self.getMDValue(field,generic="yes"))
           
   
     def findLabelsFromMapping(self,referenceType):      def findLabelsFromMapping(self,referenceType):
Line 1137  class ECHO_resource(Folder,Persistent,EC Line 1258  class ECHO_resource(Folder,Persistent,EC
           
           
   
       
   
         bibdata={}          bibdata={}
         retdata={}          retdata={}
         fieldlist=self.standardMD.fieldList          fieldlist=self.standardMD.fieldList
Line 1188  class ECHO_resource(Folder,Persistent,EC Line 1307  class ECHO_resource(Folder,Persistent,EC
         if RESPONSE:          if RESPONSE:
             return RESPONSE.redirect('manage_main')              return RESPONSE.redirect('manage_main')
                   
     def ECHO_getResourceMD(self,template="yes",back=None):              return "OK:",self.absolute_url(),self.contentType
           
       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)
   
Line 1198  class ECHO_resource(Folder,Persistent,EC Line 1319  class ECHO_resource(Folder,Persistent,EC
         if not error=="": #Fehler beim Auslesen des Metafiles          if not error=="": #Fehler beim Auslesen des Metafiles
         return "ERROR:",error          return "ERROR:",error
           
     if not self.contentType:          if (not self.contentType) or (overwrite=="yes"):
         self.contentType=metadict['bib_type'].lower()          self.contentType=metadict['bib_type'].lower()
                   
     if not (metadict['bib_type'].lower()==self.contentType.lower()):      if not (metadict['bib_type'].lower()==self.contentType.lower()):
Line 1325  class ECHO_externalLink(Folder,ECHO_basi Line 1446  class ECHO_externalLink(Folder,ECHO_basi
     security.declarePublic('content_html')      security.declarePublic('content_html')
     def content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content"""
         return ECHO_basis.content_html(self,'externalLink')          ret= ECHO_basis.content_html(self,'externalLink')
           
           
           try:
               return ret.encode('utf-8')
           
           except:
                       try: 
                           return ret.decode('latin-1')
                       except:
                
                           return ret
           
     def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):      def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
   
Line 1399  class ECHO_link(ECHO_externalLink): Line 1531  class ECHO_link(ECHO_externalLink):
   
     meta_type="ECHO_link"      meta_type="ECHO_link"
           
           manage_options = ECHO_externalLink.manage_options+(
               {'label':'add links config','action':'ECHO_link_addLinksForm'},
                   )
           
           def ECHO_link_addLinksForm(self):
               """Main configuration"""
           
               pt=zptFile(self, 'zpt/ChangeECHO_link_addLinks.zpt')
               return pt()
       
           def ECHO_link_addLinks(self,addLinks,RESPONSE):
               """add links"""
               self.addLinks=addLinks
               if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
                   
     def content_html(self):      def content_html(self):
         """template fuer link"""          """template fuer link"""
           
   
         if hasattr(self,"link_template"):          if hasattr(self,"link_template"):
             return ECHO_basis.content_html(self,'link')                          ret=ECHO_basis.content_html(self,'link')
   
         else:          else:
             return ECHO_basis.content_html(self,'collection')                          ret=ECHO_basis.content_html(self,'collection')
   
   
                   #return ret
                   return ret
   #            
   #            
   #                try:
   #                    return ret.decode('utf-8')
   #                except:
   #                    try: 
   #                        return ret.decode('latin-1')
   #                    except:
   #                
   #                        return ret
   #        
   
   
     def index_html(self):      def index_html(self):
         """standard link"""          """standard link"""
                   if self.link:
         splitted=self.link.split("?")          splitted=self.link.split("?")
         if len(splitted)>1:          if len(splitted)>1:
             params=cgi.parse_qs(splitted[1])              params=cgi.parse_qs(splitted[1])
Line 1422  class ECHO_link(ECHO_externalLink): Line 1588  class ECHO_link(ECHO_externalLink):
         else:          else:
             params={}              params={}
                   
                    if getattr(self,'addLinks','yes')=="yes":
         params['backLink']=self.aq_parent.absolute_url()          params['backLink']=self.aq_parent.absolute_url()
                        params['startLink']=splitted[0]+"?"+urllib.urlencode(params)
   
         self.REQUEST.SESSION['_ECHOLink']=splitted[0]+"?"+urllib.urlencode(params)  
                   
         return self.REQUEST.RESPONSE.redirect(splitted[0]+"?"+urllib.urlencode(params))          return self.REQUEST.RESPONSE.redirect(splitted[0]+"?"+urllib.urlencode(params))
                   else:
                    return ""
   
 def manage_addECHO_linkForm(self):  def manage_addECHO_linkForm(self):
         """Form for external Links"""          """Form for external Links"""
Line 1441  def manage_addECHO_link(self,id,title,la Line 1610  def manage_addECHO_link(self,id,title,la
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
   
       getattr(self,id).addLinks='no'
       
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
Line 1455  class ECHO_collection(Folder, Persistent Line 1626  class ECHO_collection(Folder, Persistent
   
     path="/mpiwg/online/permanent/shipbuilding"      path="/mpiwg/online/permanent/shipbuilding"
   
       def getTitleAndLabel(self):
           """gibt title und label zurueck"""
           return (getattr(self,'title',''),getattr(self,'label',''))
   
       def localizeObjects(self):
               """localize all objects"""
               contents=self.ZopeFind(self,obj_metatypes=['ECHO_externalLink','ECHO_link','ECHO_mapText'])
   
               find=self.ZopeFind(self,obj_ids=('locale_en'))
               if not find:
                   self.manage_addECHO_locale("en",'','')
               for content in contents:
   
                       if content[1].meta_type in ['ECHO_link','ECHO_externalLink']:
   
                               find=content[1].ZopeFind(content[1],obj_metatypes=('ECHO_mapText'))
                               if find:
                                       root=find[0][1]
   
                                       locale=find[0][1].ZopeFind(find[0][1],obj_ids=('locale_en'))
                               else:
                                       root=None
                       else:
                               root=content[1]
                               locale=content[1].ZopeFind(content[1],obj_ids=('locale_en'))
                       if root and not locale:
                               root.manage_addECHO_locale("en",'','')
                       
               pt=zptFile(self, 'zpt/localizeObjects.zpt')
               return pt()
   
   
       def localize(self,REQUEST,RESPONSE):
               """localize"""
               for key in REQUEST.form.keys():
                       splitted=key.split("!")
   
                       if splitted[0]=="" or splitted[0]=="en" or splitted[0]=="title" or splitted[0]=="label":
                               if splitted[0]=="en":
                                       setattr(self.locale_en,splitted[1],REQUEST.form[key])
                               else:
                                       setattr(self,splitted[0],REQUEST.form[key])
                       else:
                               obj=getattr(self,splitted[0])
   
                               if obj.meta_type=="ECHO_mapText":
                                       if splitted[1]=="en":
                                               obj.locale_en.pt_edit(REQUEST.form[key],None)
                                       else:
                                               obj.pt_edit(REQUEST.form[key],None)
                               else:
                                       text=obj.ZopeFind(obj,obj_metatypes=['ECHO_mapText'])
                                       if splitted[1]=="en":
                                               
                                               text[0][1].locale_en.pt_edit(REQUEST.form[key],None)
                                       else:
                                               text[0][1].pt_edit(REQUEST.form[key],None)
               if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
   
     def getRDF(self,urn=None):      def getRDF(self,urn=None):
         """rdf of the collection"""          """rdf of the collection"""
                   
Line 1592  class ECHO_collection(Folder, Persistent Line 1824  class ECHO_collection(Folder, Persistent
                 pass                  pass
         return ret          return ret
                 
     def updateCollection(self,RESPONSE=None):      def importCollection(self,path=None,RESPONSE=None):
         """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""          """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
         files=os.listdir(self.path)          
           if path is None:
                   pt=zptFile(self, 'zpt/importCollection.zpt')
                   return pt()
   
           files=os.listdir(path)
     ret=""      ret=""
         for fileName in files:          for fileName in files:
                           
             if fileName:              if fileName:
                   
         tempPath=re.sub("/mpiwg/online","",self.path)                  tempPath=re.sub("/mpiwg/online","",path)
         link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"          link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"
                   
         metalink=self.path+"/"+fileName+"/index.meta"          metalink=self.path+"/"+fileName+"/index.meta"
Line 1623  class ECHO_collection(Folder, Persistent Line 1860  class ECHO_collection(Folder, Persistent
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def updateCollectionMD(self,RESPONSE=None):  
         """updateMD"""  
         files=os.listdir(self.path)  
         for fileName in files:  
             if fileName:  
                 genObj=getattr(self,fileName)  
                 genObj.copyIndex_meta2echo_resource()  
                 genObj.generate_title()  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
   
   
     def changeViewerTemplateSetsForm(self):      def changeViewerTemplateSetsForm(self):
         """change the viewer template set"""          """change the viewer template set"""
         pt=zptFile(self, 'zpt/changeViewerTemplateSet')          pt=zptFile(self, 'zpt/changeViewerTemplateSet')
Line 1727  class ECHO_collection(Folder, Persistent Line 1950  class ECHO_collection(Folder, Persistent
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
     def copySearchFields(self,RESPONSE=None):      def copySearchFields(self,RESPONSE=None):
         """copys import metadatafields to the object"""              """copys < metadatafields to the object"""
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
         for resource in resources:          for resource in resources:
   
Line 1746  class ECHO_collection(Folder, Persistent Line 1969  class ECHO_collection(Folder, Persistent
     def reloadMetaDataFromStorage(self,RESPONSE=None):      def reloadMetaDataFromStorage(self,RESPONSE=None):
         """copy metadata from the storage to ECHO"""          """copy metadata from the storage to ECHO"""
   
         return reloadMetaDataFromStorage(self,RESPONSE=None)              return reloadMetaDataFromStorage(self,RESPONSE)
   
           
     def getPartnerCopyright(self,name,sonst="generic"):      def getPartnerCopyright(self,name,sonst="generic"):
Line 1815  class ECHO_collection(Folder, Persistent Line 2038  class ECHO_collection(Folder, Persistent
   
     def addMovie(self,id,title,label,description,contentType,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits=None,coords=None,RESPONSE=None):      def addMovie(self,id,title,label,description,contentType,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits=None,coords=None,RESPONSE=None):
         """SSS"""          """SSS"""
     print "we are here"  
     #manage_addECHO_movie(self,id,title,label,description,responsible,link,thumbUrl,rawFile,metalink,weight,credits=None,coords=None,RESPONSE=None)      #manage_addECHO_movie(self,id,title,label,description,responsible,link,thumbUrl,rawFile,metalink,weight,credits=None,coords=None,RESPONSE=None)
     if not hasattr(self,id):      if not hasattr(self,id):
         try:          try:
Line 1949  class ECHO_collection(Folder, Persistent Line 2172  class ECHO_collection(Folder, Persistent
         {'label':'Main Config','action':'ECHO_collection_config'},          {'label':'Main Config','action':'ECHO_collection_config'},
         {'label':'Change Labels','action':'changeLabels'},          {'label':'Change Labels','action':'changeLabels'},
         {'label':'Change Titles','action':'changeTitles'},          {'label':'Change Titles','action':'changeTitles'},
           {'label':'Localize','action':'localizeObjects'},
     {'label':'Change Weights','action':'changeWeights'},      {'label':'Change Weights','action':'changeWeights'},
         {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},          {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},
         {'label':'Graphic Coords','action':'ECHO_graphicEntry'},          {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
Line 1956  class ECHO_collection(Folder, Persistent Line 2180  class ECHO_collection(Folder, Persistent
     {'label':'Set Startpage','action':'setStartpageFolderForm'},      {'label':'Set Startpage','action':'setStartpageFolderForm'},
         {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},          {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},
     {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},      {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
     {'label':'ImportCollection','action':'updateCollection'},          {'label':'ImportCollection','action':'importCollection'},
     {'label':'Copy MD for indexing and search','action':'copySearchFields'},      {'label':'Copy MD for indexing and search','action':'copySearchFields'},
         )          )
   
Line 1984  class ECHO_collection(Folder, Persistent Line 2208  class ECHO_collection(Folder, Persistent
   
                   
     security.declarePublic('changeECHO_collection')           security.declarePublic('changeECHO_collection')     
     def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",location=None,isAlwaysClickable=None):      def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",location=None,isAlwaysClickable=None,prefix="",suffix=""):
         """Aenderung der Properties"""          """Aenderung der Properties"""
   
         self.secondaryLink=secondaryLink          self.secondaryLink=secondaryLink
Line 1993  class ECHO_collection(Folder, Persistent Line 2217  class ECHO_collection(Folder, Persistent
     self.bgcolour=bgcolour      self.bgcolour=bgcolour
         self.location=location          self.location=location
     self.isAlwaysClickable=isAlwaysClickable      self.isAlwaysClickable=isAlwaysClickable
           self.prefix=prefix[0:]
           self.suffix=suffix[0:]
                           
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)          setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
                   
Line 2050  class ECHO_collection(Folder, Persistent Line 2276  class ECHO_collection(Folder, Persistent
     def content_html(self,**argv):      def content_html(self,**argv):
         """template fuer content"""          """template fuer content"""
     #print "NN",argv      #print "NN",argv
         return ECHO_basis.content_html(self,'collection')          ret = ECHO_basis.content_html(self,'collection')
           
           try:
                   return ret.encode('utf-8')
           except:
               
               try: 
                   return ret.decode('latin-1')
               except:
                   
                   return ret
           
     def getCredits(self):      def getCredits(self):
         """Ausgabe der credits"""          """Ausgabe der credits"""
Line 2408  class ECHO_root(Folder,Persistent,Implic Line 2644  class ECHO_root(Folder,Persistent,Implic
           
     meta_type="ECHO_root"      meta_type="ECHO_root"
   
       
       def findObjectFromFulltext(self,existUri):
           '''
           
           @param url:
           @param existUri:
           '''
   
           if existUri:
               #TODO: at the moment assume that the filename is unique, the whole has to changed to a system of ids.
               filename=existUri.split("/")[-1]
           
           founds=self.resourceCatalog.search({'fullTextUrl':os.path.splitext(filename)[0]})  
           
           ret=[(found.title,found.getObject().absolute_url(),found.getObject().aq_parent.absolute_url()) for found in founds]
           
           return ret
           
       def reindex(self,RESPONSE=None):
           """indiziere alle Objecte neu"""
           
           if RESPONSE:
               RESPONSE.write("<html><body>")
           
           resources=self.ZopeFind(self,obj_metatypes=["ECHO_resource"], search_sub=1)
           
           for resource in resources:
               resource[1].reindex()
               print "<p> done %s </p>\n"
               if RESPONSE:
                   RESPONSE.write("<p> done %s </p>\n"%resource[0])
                   
           if RESPONSE:
               RESPONSE.write("<p> ok </p></html></body>\n")
               
     def printer(self,txt):      def printer(self,txt):
         print txt          print txt
         print txt[2]          print txt[2]
Line 2422  class ECHO_root(Folder,Persistent,Implic Line 2693  class ECHO_root(Folder,Persistent,Implic
     def item2(self,txt):      def item2(self,txt):
         return txt[2]          return txt[2]
                   
       def setLanguage(self,lang):
               """Set language cookie"""
               self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")
   
       def switchLanguage(self):
               """Set language cookie"""
               if self.getLanguage()=="en":
                       lang="de"
               else:
                       lang="en"
               
               self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")
               self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1'])
       def getLanguage(self):
               """get language cookie"""
               lang= self.REQUEST.cookies.get('lang_exhibition','de')
               if lang == '':
                       lang="de"
               return lang
       
     def getContentOverviewTemplate(self):      def getContentOverviewTemplate(self):
     """produces overview template with macro"""      """produces overview template with macro"""
     pt = zptObjectOrFile(self, 'content_overview_template')      pt = zptObjectOrFile(self, 'content_overview_template')
Line 2927  class ECHO_root(Folder,Persistent,Implic Line 3218  class ECHO_root(Folder,Persistent,Implic
         else:          else:
             return ""              return ""
                   
     def link2html(self,str):      link2html=vlp_xmlhelpers.link2html
         """link2html fuer VLP muss hier noch raus"""  
         if str:  
   
             str=re.sub("\&","&amp;",str)  
             dom=xml.dom.minidom.parseString("<?xml version='1.0' encoding='utf-8'?><txt>"+str+"</txt>")  
             links=dom.getElementsByTagName("link")  
               
   
             for link in links:  
                 link.tagName="a"  
         ref=link.getAttribute("ref")  
         pn=link.getAttribute("page")  
               
                 if self.checkRef(ref):  
             if pn:  
                 link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref+"&page="+pn)  
             else:  
                 link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref)  
   
   
             newxml=dom.toxml('utf-8')  
         
         retStr=regexpTXT.search(newxml)  
   
         return retStr.group(1)  
   
                  
         return ""  
   
     def xml2html(self,str,quote="yes"):  
         """link2html fuer VLP muss hier noch raus"""  
   
         if str:  
             if quote=="yes2":  
                 str=re.sub("\&","&amp;",str)  
             #dom=xml.dom.minidom.parseString(str)  
         dom = NonvalidatingReader.parseString(str,"http://www.mpiwg-berlin.mpg.de/")  
             #links=dom.getElementsByTagName("link")  
             links=Ft.Xml.XPath.Evaluate(".//link", contextNode=dom)  
             for link in links:  
                 #link.tagName="a"  
           
                 ref=link.getAttributeNS(EMPTY_NAMESPACE,"ref")      xml2html=vlp_xmlhelpers.xml2html
         pn=link.getAttributeNS(EMPTY_NAMESPACE,"page")  
   
         cns=link.childNodes[0:]  
           
         newLink=dom.createElementNS(EMPTY_NAMESPACE,"a")  
         for x in cns:  
             newLink.appendChild(x)  
           
               
           
         link.parentNode.replaceChild(newLink,link)  
                 if self.checkRef(ref):  
             if pn:  
                 newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn)  
             else:  
                 newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)  
   
             #str= dom.toxml('utf-8')  
         buf = cStringIO.StringIO()  
         PrettyPrint(dom, stream=buf, encoding='UTF-8')  
         str = buf.getvalue()  
         buf.close()  
         #str=PrettyPrint(dom.documentElement,encoding='UTF-8')  
         #print link.toxml('utf-8')  
         #print type(str)  
         retStr=regexpPage.search(str)  
         try: # hack warum fehtl manchmal page??  
             return retStr.group(1)  
         except:  
             return str  
         return ""  
   
     def checkRef(self,ref):  
         if ref[0:3]=='lit':  
             if len(self.library_data({ 'id':ref}))>0:  
                 return 1  
         try:  
             if ref[0:7]=="tec_cat":  
                 return 1  
         except:  
             """nothing"""  
                           
         dbs={'vl_technology':'','vl_people':'','vl_sites':''}      checkRef=vlp_xmlhelpers.checkRef
         res=None  
         for db in dbs.keys():  
             res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))  
         return res  
                                                                           
     #Ende Methode fuer vlp  #    def checkRef(self,ref):
   #            if ref[0:3]=='lit':
   #                    if len(self.library_data({ 'id':ref}))>0:
   #                            return 1
   #            try:
   #                    if ref[0:7]=="tec_cat":
   #                            return 1
   #            except:
   #                    """nothing"""
   #                    
   #            dbs={'vl_technology':'','vl_people':" AND complete='yes'",'vl_sites':''}
   #            res=None
   #            for db in dbs.keys():
   #                    res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
   #            return res
   #                                    
   #    #Ende Methode fuer vlp
   
     def PgQuoteString(self,string):      def PgQuoteString(self,string):
         """Quote string"""          """Quote string"""
Removed from v.1.227  
changed lines
  Added in v.1.253

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