[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.218 and 1.245

version 1.218, 2005/03/07 21:25:09 version 1.245, 2005/10/28 17:49:45
Line 1 Line 1
   
 """New version of the product started February, 8th. Without scientific classification, use content-type for further classification."""  """New version of the product started February, 8th. Without scientific classification, use content-type for further classification."""
 """Echo collection provides the classes for the ECHO content web-site.  """Echo collection provides the classes for the ECHO content web-site.
   
Line 38  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 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
   
     security.declareProtected('View','index_html')      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')
Line 875  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 968  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 empty:          if not empty:
             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)
                   
Line 988  class ECHO_resource(Folder,Persistent,EC Line 1080  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 996  class ECHO_resource(Folder,Persistent,EC Line 1088  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 1057  class ECHO_resource(Folder,Persistent,EC Line 1176  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 1086  class ECHO_resource(Folder,Persistent,EC Line 1192  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 1140  class ECHO_resource(Folder,Persistent,EC Line 1247  class ECHO_resource(Folder,Persistent,EC
           
           
   
       
   
         bibdata={}          bibdata={}
         retdata={}          retdata={}
         fieldlist=self.standardMD.fieldList          fieldlist=self.standardMD.fieldList
Line 1191  class ECHO_resource(Folder,Persistent,EC Line 1296  class ECHO_resource(Folder,Persistent,EC
         if RESPONSE:          if RESPONSE:
             return RESPONSE.redirect('manage_main')              return RESPONSE.redirect('manage_main')
                   
               return "OK:",self.absolute_url().self,contentType
           
     def ECHO_getResourceMD(self,template="yes",back=None):      def ECHO_getResourceMD(self,template="yes",back=None):
         """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 1201  class ECHO_resource(Folder,Persistent,EC Line 1308  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:
                   self.contentType=metadict['bib_type'].lower()
   
     if not (metadict['bib_type'].lower()==self.contentType.lower()):      if not (metadict['bib_type'].lower()==self.contentType.lower()):
         self.REQUEST.SESSION['contentStorage']=metadict['bib_type']          self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
Line 1239  class ECHO_resource(Folder,Persistent,EC Line 1348  class ECHO_resource(Folder,Persistent,EC
             return None              return None
                   
                   
       security.declareProtected('View','index_html')
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
         pdf=self.checkRDF(self.link)          pdf=self.checkRDF(self.link)
Line 1307  def manage_addECHO_resourceForm(self): Line 1417  def manage_addECHO_resourceForm(self):
   
   
 def manage_addECHO_resource(self,id,title,label,description="",responsible="",link="",metalink="",weight="",copyrightType=None,resourceID=None,contentType=None,renderingType=None,credits=None,coords=None,RESPONSE=None):  def manage_addECHO_resource(self,id,title,label,description="",responsible="",link="",metalink="",weight="",copyrightType=None,resourceID=None,contentType=None,renderingType=None,credits=None,coords=None,RESPONSE=None):
     """addaresource"""      """addresource"""
   
     newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)      newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
   
Line 1368  class ECHO_externalLink(Folder,ECHO_basi Line 1478  class ECHO_externalLink(Folder,ECHO_basi
                           
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Main Config','action':'ECHO_externalLink_config'},          {'label':'Main Config','action':'ECHO_externalLink_config'},
           {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
         )          )
   
                   
Line 1397  class ECHO_link(ECHO_externalLink): Line 1508  class ECHO_link(ECHO_externalLink):
     """external_link"""      """external_link"""
   
     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')
   
                   try:
                       return ret.decode('utf-8')
                   except:
                       return ret
                   
           def index_html(self):
                   """standard link"""
                   if self.link:
                    splitted=self.link.split("?")
                    if len(splitted)>1:
                           params=cgi.parse_qs(splitted[1])
   
                           for x in params.keys():
                                   if type(params[x]) is ListType:
                                           params[x]=params[x][0]
           
   
                    else:
                           params={}
                   
                    if getattr(self,'addLinks','yes')=="yes":
                        params['backLink']=self.aq_parent.absolute_url()
                        params['startLink']=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 1419  def manage_addECHO_link(self,id,title,la Line 1574  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 1433  class ECHO_collection(Folder, Persistent Line 1590  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 1530  class ECHO_collection(Folder, Persistent Line 1748  class ECHO_collection(Folder, Persistent
         ret=""          ret=""
         argv=self.REQUEST.form          argv=self.REQUEST.form
                   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
         for resource in resources:          for resource in resources:
                         
             try:              try:
Line 1545  class ECHO_collection(Folder, Persistent Line 1763  class ECHO_collection(Folder, Persistent
         ret=""          ret=""
         argv=self.REQUEST.form          argv=self.REQUEST.form
                   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
         for resource in resources:          for resource in resources:
                         
             try:              try:
Line 1555  class ECHO_collection(Folder, Persistent Line 1773  class ECHO_collection(Folder, Persistent
                 pass                  pass
         return ret          return ret
                   
       def changeLabelsInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
               for resource in resources:
                      
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].label=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
          
     def updateCollection(self,RESPONSE=None):      def updateCollection(self,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)          files=os.listdir(self.path)
Line 1691  class ECHO_collection(Folder, Persistent Line 1924  class ECHO_collection(Folder, Persistent
                           
     def copySearchFields(self,RESPONSE=None):      def copySearchFields(self,RESPONSE=None):
         """copys import metadatafields to the object"""          """copys import 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 1709  class ECHO_collection(Folder, Persistent Line 1942  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 1776  class ECHO_collection(Folder, Persistent Line 2009  class ECHO_collection(Folder, Persistent
             return ""              return ""
   
   
     def addMovie(self,id,title,label,description,contentType,responsible,link,thumbUrl,rawFile,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:
             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,lowresFile,metalink,weight,credits=None,coords=None,RESPONSE=None)
             return "done"              return "done"
         except:          except:
             return None              return None
     else:      else:
         obj=getattr(self,id)          obj=getattr(self,id)
         obj.changeECHO_movie_main(metalink,link,rawFile,thumbUrl,title,label,description,contentType,weight=weight)                  obj.changeECHO_movie_main(metalink,link,rawFile,lowresFile,thumbUrl,title,label,description,contentType,weight=weight)
   
           return "changed"
                   
     def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):      def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
         """SSS"""          """SSS"""
Line 1910  class ECHO_collection(Folder, Persistent Line 2145  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 1945  class ECHO_collection(Folder, Persistent Line 2181  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 1954  class ECHO_collection(Folder, Persistent Line 2190  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 1978  class ECHO_collection(Folder, Persistent Line 2216  class ECHO_collection(Folder, Persistent
         pt=zptFile(self, 'zpt/ECHO_content_overview.zpt')          pt=zptFile(self, 'zpt/ECHO_content_overview.zpt')
         return pt()          return pt()
   
     security.declareProtected('View','index_html')  
           
       security.declareProtected('View','index_html')
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
         if self.ZCacheable_isCachingEnabled():          if self.ZCacheable_isCachingEnabled():
Line 2011  class ECHO_collection(Folder, Persistent Line 2249  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 2048  class ECHO_collection(Folder, Persistent Line 2296  class ECHO_collection(Folder, Persistent
         """javascript"""          """javascript"""
         return sendFile(self, 'js/hl_add.js', 'text/plain')          return sendFile(self, 'js/hl_add.js', 'text/plain')
   
     def getAllMapAreas(self):      def getAllMapAreas(self,mapColTypes=['ECHO_collection','ECHO_resource','ECHO_link','ECHO_externalLink']):
         """Give list of coordinates"""          """Give list of coordinates"""
         mapColTypes=['ECHO_collection','ECHO_resource']          
         areas=[]          areas=[]
         for entry in self.getSubCols(subColTypes=mapColTypes):          for entry in self.getSubCols(subColTypes=mapColTypes):
             object=entry              object=entry
Line 2369  class ECHO_root(Folder,Persistent,Implic Line 2617  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 2383  class ECHO_root(Folder,Persistent,Implic Line 2666  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')
     return pt      return pt
   
       def mapstyle_css(self):
           """send mapstyle.css"""
           sendFile(self, 'html/ECHO_mapstyle.css', 'text/css')
   
   
     ###Cdli adds -> have to be removed      ###Cdli adds -> have to be removed
     def getTablet(self,item):      def getTablet(self,item):
         #print "getTablet"          #print "getTablet"
Line 2688  class ECHO_root(Folder,Persistent,Implic Line 2996  class ECHO_root(Folder,Persistent,Implic
          """nothing"""           """nothing"""
      return retStr       return retStr
   
     def renderingTypeSelector_HTML(self,selected=None):  
          """give type selector"""  
      if not selected:  
          retStr="<option selected>\n"  
      else:  
          retStr="<option>\n"  
            
      try: # erste version renderingTypes exists  
          for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):  
              if selected and (renderingType[0]==selected):  
                  retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])  
              else:                  
                  retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])  
      except:  
          """nothing"""  
      return retStr  
   
   
     def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):      def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):
          """give type selector"""           """give type selector"""
Line 2900  class ECHO_root(Folder,Persistent,Implic Line 3191  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")  
         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)      xml2html=vlp_xmlhelpers.xml2html
                 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.218  
changed lines
  Added in v.1.245

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