[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.14 and 1.89

version 1.14, 2004/02/11 17:45:29 version 1.89, 2004/05/24 19:04:09
Line 11  class ECHO_externalLink contains informa Line 11  class ECHO_externalLink contains informa
 """  """
 import string  import string
 import re  import re
   import os
 import OFS.Image  import OFS.Image
 from types import *  from types import *
 from OFS.Image import Image  from OFS.Image import Image
Line 18  from Globals import DTMLFile Line 19  from Globals import DTMLFile
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 from AccessControl import ClassSecurityInfo  from AccessControl import ClassSecurityInfo
   from AccessControl.User import UserFolder
 from Globals import InitializeClass  from Globals import InitializeClass
 from Globals import DTMLFile  from Globals import DTMLFile
   import Globals
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Globals import Persistent  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   from Globals import Persistent, package_home
 from Acquisition import Implicit  from Acquisition import Implicit
   from ECHO_helpers import displayTypes
   
   
   try:
       from psycopg import libpq
   except:
       try:
 from pyPgSQL import libpq  from pyPgSQL import libpq
       except:
           print "ECHO_collection: Warning - No libpq imported!"
           
 import xml.dom.minidom  import xml.dom.minidom
   
 import urllib  import urllib
 import xml.dom.minidom  import xml.dom.minidom
   from ECHO_graphicalOverview import javaHandler,javaScriptMain
   import ECHO_helpers
   
 #List of different types for the graphical linking viewer  #List of different types for the graphical linking viewer
 viewClassificationListMaster=['view point','area']  viewClassificationListMaster=['view point','area']
   
   def checkDiffs(self,metadict):
           """check differences"""
   
           def NoneToEmpty(obj):
               if obj:
                   return obj
               else:
                   return ""
           
           diffs={}
           tags=self.findTagsFromMapping(self.contentType)
           for field in tags[1]:
               try:
                   if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
                       diffs[self.getFieldTag(tags,field)]=1
                   else:
                       print "DIFF",field,self.getFieldValue(self.getFieldTag(tags,field)),metadict[self.getFieldTag(tags,field)]
                       diffs[self.getFieldTag(tags,field)]=0
               except:
                   diffs[self.getFieldTag(tags,field)]=0
                   print "EX",field
           return diffs
       
   def content_html(self,type):
           """template fuer content"""
           #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
           #
           #if templates:
           #    return templates[0][1]()
   
           try:
               obj=getattr(self,type+"_template")
               return obj()
           except:
               pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)
               pt.content_type="text/html"
               return pt()
   
 def toList(field):  def toList(field):
     """Einzelfeld in Liste umwandeln"""      """Einzelfeld in Liste umwandeln"""
Line 51  def getText(nodelist): Line 103  def getText(nodelist):
     return rc      return rc
   
   
   def sendFile(self, filename, type):
       """sends an object or a local file (in the product) as response"""
       paths = filename.split('/')
       object = self
       # look for an object called filename
       for path in paths:
           if hasattr(object, path):
           object = getattr(object, path)
       else:
           object = None
           break
       if object:
       # if the object exists then send it
       return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
       else:
       # send a local file with the given content-type
       fn = os.path.join(package_home(globals()), filename)
       self.REQUEST.RESPONSE.setHeader("Content-Type", type)
       self.REQUEST.RESPONSE.write(file(fn).read())
       return
   
   class BrowserCheck:
       """check the browsers request to find out the browser type"""
       
       def __init__(self, zope):
       self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")
       self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and (string.find(self.ua, 'MSIE') < 0)
       self.isIE = string.find(self.ua, 'MSIE') > -1
       self.nav = self.ua[string.find(self.ua, '('):]
       ie = string.split(self.nav, "; ")[1]
       if string.find(ie, "MSIE") > -1:
           self.versIE = string.split(ie, " ")[1]
       self.isMac = string.find(self.ua, 'Macintosh') > -1
       self.isWin = string.find(self.ua, 'Windows') > -1
       self.isIEWin = self.isIE and self.isWin
       self.isIEMac = self.isIE and self.isMac
   
   
   def writeMetadata(url,metadict):
       """Einlesen der Metadaten und und erstellen des geaenderten XML file"""
   
       try:
           geturl=""
           for line in urllib.urlopen(url).readlines():
               geturl=geturl+line
           
           
       except:
           return (None,"Cannot open: "+url)
   
       try:
           dom=xml.dom.minidom.parseString(geturl)
       except:
           return (None,"Cannot parse: "+url+"<br>"+geturl)
   
       metanodes=dom.getElementsByTagName('bib')
   
       if not metanodes:
           metanodes=dom.getElementsByTagName('archimedes')
   
       metanode=metanodes[0]
   
       for metaData in metadict.keys():
           print metaData,metanode
           try:
               nodeOld=metanode.getElementsByTagName(metaData)
           except:
               nodeOld=None
               
           if nodeOld:
               metanode.removeChild(nodeOld[0]).unlink()
           else:
               # try also old writing rule - instead of _:
               try:
                   nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
               except:
                   nodeOld=None
                   
               if nodeOld:
                   metanode.removeChild(nodeOld[0]).unlink()
   
           metanodeneu=dom.createElement(metaData)
           metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf8"))
           metanodeneu.appendChild(metanodetext)
           metanode.appendChild(metanodeneu)
   
       
       return dom.topxml().encode('utf-8')
   
 def readMetadata(url):  def readMetadata(url):
     """Methoden zum Auslesen der Metadateninformation zu einer Resource      """Methode zum Auslesen der Metadateninformation zu einer Resource
     Vorerst noch Typ bib"""      Vorerst noch Typ bib"""
           
     metadict={}      metadict={}
Line 87  def readMetadata(url): Line 228  def readMetadata(url):
                   
         for node in metacontent:          for node in metacontent:
             try:              try:
                 metadict[node.tagName.lower()]=getText(node.childNodes)                  metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)
             except:              except:
                 """nothing"""                  """nothing"""
   
     #print metadict  
     return metadict,""      return metadict,""
           
   
 def setECHO_collectionInformation(self,title,label,description,content_type,responsible,credits,weight,coordstrs,viewClassification=""):  def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):
   
         """Allegemeine Informationen zu einer ECHO Collection"""          """Allegemeine Informationen zu einer ECHO Collection"""
   
Line 104  def setECHO_collectionInformation(self,t Line 245  def setECHO_collectionInformation(self,t
         self.label = label          self.label = label
         self.title=title          self.title=title
         self.description=description          self.description=description
         self.content_type=content_type          self.contentType=contentType
         self.responsible=responsible          self.responsible=responsible
         self.credits=toList(credits)          self.credits=toList(credits)
         self.weight=weight          self.weight=weight
Line 172  class scientificInformation(Folder,Persi Line 313  class scientificInformation(Folder,Persi
     def get_period(self):      def get_period(self):
         return self.period          return self.period
   
   class ECHO_layoutTemplate(ZopePageTemplate):
       """Create a layout Template for different purposes"""
   
       meta_type="ECHO_layoutTemplate"
   
       def __init__(self, id, text=None, content_type=None,EchoType=None):
           self.id = str(id)
   
   
   
           self.ZBindings_edit(self._default_bindings)
           if text is None:
               self._default_content_fn = os.path.join(package_home(globals()),
                                                  'zpt/ECHO_%s_template_standard.zpt'%EchoType)
               text = open(self._default_content_fn).read()
           self.pt_edit(text, content_type)
   
       
           """change form"""
   
   
   def manage_addECHO_layoutTemplateForm(self):
       """Form for adding"""
       pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_layoutTemplate.zpt').__of__(self)
       return pt()
   
   from urllib import quote
   
   
   def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
       "Add a Page Template with optional file content."
       if type(EchoType)==StringType:
           EchoTypes=[EchoType]
       else:
           EchoTypes=EchoType
           
       for singleType in EchoTypes:
   
           id = str(singleType)+"_template"
           if REQUEST is None:
               self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))
               ob = getattr(self, id)
               
               if title:
                   ob.pt_setTitle(title)
               return ob
           else:
               file = REQUEST.form.get('file')
               headers = getattr(file, 'headers', None)
               if headers is None or not file.filename:
                   zpt = ECHO_layoutTemplate(id,EchoType=singleType)
               else:
                   zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))
   
               self._setObject(id, zpt)
               ob = getattr(self, id)
               if title:
                   ob.pt_setTitle(title)
   
               try:
                   u = self.DestinationURL()
               except AttributeError:
                   u = REQUEST['URL1']
   
               
       REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
 class ECHO_resource(Folder):  class ECHO_resource(Folder):
     """ECHO Ressource"""      """ECHO Ressource"""
Line 179  class ECHO_resource(Folder): Line 387  class ECHO_resource(Folder):
   
     viewClassificationList=viewClassificationListMaster      viewClassificationList=viewClassificationListMaster
   
       getSubCols = ECHO_helpers.getSubCols
       def getTitle(self):
       """title"""
       return self.title.encode('utf-8') 
   
       def getLabel(self):
       """title"""
       return self.label.encode('utf-8') 
   
       def content_html(self):
           """template fuer content"""
           return content_html(self,'resource')
       
     def getViewClassification(self):      def getViewClassification(self):
         if hasattr(self,'viewClassification'):          if hasattr(self,'viewClassification'):
             return self.viewClassification              return self.viewClassification
         else:          else:
             return ""              return ""
                   
       def getFullTextXML(self,noredirect=None):
           """getFullTextXML"""
           try:
               fh=urllib.urlopen(self.metalink)
               dom=xml.dom.minidom.parse(fh)
               texttools=dom.getElementsByTagName('texttool')
               text=texttools[0].getElementsByTagName('text')
               texturl=getText(text[0].childNodes)
               if not noredirect:
                   self.REQUEST.RESPONSE.redirect(texturl)
               else:
                   return texturl
           except:
               return None
       
     def getCredits(self):      def getCredits(self):
         """Ausgabe der credits"""          """Ausgabe der credits"""
         if self.credits:          if self.credits:
Line 192  class ECHO_resource(Folder): Line 428  class ECHO_resource(Folder):
         else:          else:
             return []              return []
           
     def __init__(self,id,link,metalink,title,label,description,content_type,responsible,credits,weight,coords):      def __init__(self,id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords):
   
         self.id = id          self.id = id
         """Festlegen der ID"""          """Festlegen der ID"""
Line 204  class ECHO_resource(Folder): Line 440  class ECHO_resource(Folder):
         self.weight=weight          self.weight=weight
         self.credits=toList(credits)          self.credits=toList(credits)
         self.description=description          self.description=description
         self.content_type=content_type          self.contentType=contentType
         self.responsible=responsible          self.responsible=responsible
                   
         if coords:          if coords:
Line 216  class ECHO_resource(Folder): Line 452  class ECHO_resource(Folder):
   
   
     def getCoords(self):      def getCoords(self):
           """gibt coordinaten als String zurück und löscht zugleich einträge die keine Koordinaten sind, letzteres zur korrektur der Eingabe der alten version"""
           retList=[]
           if hasattr(self,'coords'):
               for x in self.coords:
               if len(x)>1:
                   retList.append(string.join(x,","))
           return retList
   
       
   
       def getContentType(self):
         try:          try:
             return [string.join(x,",") for x in self.coords]                return self.contentType
         except:          except:
             return []              return ""
   
       def getCopyrightType(self):
           try:
               return self.copyrightType
           except:
               return ""
   
       def getRenderingType(self):
           try:
               return self.renderingType
           except:
               return ""
   
     def ECHO_resource_config(self):      def ECHO_resource_config(self):
         """Main configuration"""          """Main configuration"""
   
         if not hasattr(self,'weight'):          if not hasattr(self,'weight'):
             self.weight=""              self.weight=""
         if not hasattr(self,'coords'):  
             self.coords=[]  
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)          pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)
         return pt()          return pt()
           
   
     def changeECHO_resource(self,metalink,link,title,label,description,content_type,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):      def ECHO_resource_config_main(self):
           """Main configuration"""
   
           if not hasattr(self,'weight'):
               self.weight=""
   
           pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)
           return pt()
   
       def ECHO_resource_config_coords(self):
           """Coords configuration """
   
           pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_coords.zpt').__of__(self)
           return pt()
   
       def ECHO_resource_config_credits(self):
           """Main configuration"""
   
           pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)
           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)
               #print data_neu, getattr(self,data)
           #print self.metaDataHash,self.metadata
       
           pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)
           return pt()
   
   
       
   
       def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):
         """Änderung der Properties"""          """Änderung der Properties"""
       self.resourceID=resourceID
       self.title=title
       self.label=label
       self.description=description
   
       self.contentType=contentType
       self.renderingType=renderingType
       self.weight=weight
       
           self.link=link
           self.metalink=metalink
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
                   
   
         setECHO_collectionInformation(self,title,label,description,content_type,responsible,credits,weight,coords,viewClassification)      def changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):
           """Änderung der Properties - coords"""
   
       if type(coords)==StringType:
               coords=[coords]
                   
           try:        
               coordsnew=[ string.split(x,",") for x in coords]
           except:
           coordsnew=[]    
   
       self.coords=coordsnew[0:]
       self.viewClassification=viewClassification
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
           """Änderung der Properties"""
       self.credits=credits
       self.responsible=responsible
       self.copyrightType=copyrightType
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
       def changeECHO_resource_metadata(self,RESPONSE=None):
           """change metadata"""
           tags=self.findTagsFromMapping(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:
                   """nothing"""
   
           return urllib.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')).read()
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
       def newMetaXML(self):
           """new index.meta"""
           self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
           return writeMetadata(self.metalink,self.OSAS_meta)
   
       
       def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):
           """Änderung der Properties"""
           
       try:        
               coordsnew=[ string.split(x,",") for x in coords]
           except:
           coordsnew=[]    
           
           setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
       self.viewClassification=viewClassification
           self.coords=coordsnew[0:]
         self.link=link          self.link=link
         self.metalink=metalink          self.metalink=metalink
                   
Line 251  class ECHO_resource(Folder): Line 616  class ECHO_resource(Folder):
                           
                           
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Main Config','action':'ECHO_resource_config'},          {'label':'Main Config','action':'ECHO_resource_config_main'},
         {'label':'Metadata','action':'ECHO_getResourceMD'},      {'label':'Change Credits & Copyright','action':'ECHO_resource_config_credits'},
         {'label':'Graphics','action':'ECHO_graphicEntry'},      {'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
       {'label':'Change Coords','action':'ECHO_resource_config_coords'},
       {'label':'Add coords','action':'ECHO_graphicEntry'},
           {'label':'Sync Metadata','action':'ECHO_getResourceMD'},
         )          )
   
       def getOverview(self):
           """overview graphics"""
           
           return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
   
     def ECHO_graphicEntry(self):      def ECHO_graphicEntry(self):
         """DO nothing"""          """DO nothing"""
         if 'overview' in self.aq_parent.__dict__.keys():          overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
           if overview: 
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)              pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
             return pt()              return pt()
         else:          else:
Line 276  class ECHO_resource(Folder): Line 650  class ECHO_resource(Folder):
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('ECHO_graphicEntry')              RESPONSE.redirect('ECHO_graphicEntry')
   
   
       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
   
       
           
       def getFieldValue(self,field):
           """get value"""
       #print field
           try:
       
               ret=self.metaDataHash[field]
               if ret == "":
                   return None
               else:
                   return ret
           except:
               return None
   
       def findLabelsFromMapping(self,referenceType):
           """gib hash mit label -> generic zurueck"""
           self.referencetypes=self.ZopeFind(self.standardMD)
       #print "RT",referenceType
       
           bibdata={}
           retdata={}
           fieldlist=self.standardMD.fieldList
           
       for referenceTypeF in self.referencetypes:
           #print referenceTypeF[1].title,referenceType    
           if referenceTypeF[1].title.lower() == referenceType.lower():
               #print "OK"
               try:
                   bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
                   referenceType=referenceTypeF[1].title
               except:
                   bibdata[referenceType]=referenceTypeF[1].fields
           
   
               bibdata['data']=referenceTypeF[1]
               self.fields=bibdata[referenceType]
                           for field in fieldlist:
                               retdata[field]=referenceTypeF[1].getValue(field)[1]
       #print retdata,fieldlist
           return retdata,fieldlist
   
       def findTagsFromMapping(self,referenceType):
           """gib hash mit label -> generic zurueck"""
           self.referencetypes=self.ZopeFind(self.standardMD)
       
       
           bibdata={}
           retdata={}
           fieldlist=self.standardMD.fieldList
           
       for referenceTypeF in self.referencetypes:
       
           if referenceTypeF[1].title.lower() == referenceType.lower(): 
               try:
                   bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
                   referenceType=referenceTypeF[1].title
               except:
                   bibdata[referenceType]=referenceTypeF[1].fields
               bibdata['data']=referenceTypeF[1]
               self.fields=bibdata[referenceType]
                           for field in fieldlist:
                               retdata[field]=referenceTypeF[1].getValue(field)[0]
       
           return retdata,fieldlist
   
       
       
               
     def ECHO_getResourceMD(self,template="yes"):      def ECHO_getResourceMD(self,template="yes"):
         """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 284  class ECHO_resource(Folder): Line 760  class ECHO_resource(Folder):
   
         if not error=="": #Fehler beim Auslesen des Metafiles          if not error=="": #Fehler beim Auslesen des Metafiles
             return "ERROR:",error              return "ERROR:",error
         for key in metadict.keys():#Hinzufügen der Felder  
   
             setattr(self,key,metadict[key].encode('ascii','replace'))  
                   
       if not (metadict['bib_type'].lower()==self.contentType.lower()):
           self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
           self.REQUEST.SESSION['contentZope']=self.contentType
   
           return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()
   
         self.metadata=metadict.keys()          self.REQUEST.SESSION['metadict']=metadict
   
       self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)
   
         self.label=self.generate_label()  
                   
         if template=="yes":          if template=="yes":
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)              pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)
             return pt()              return pt()
           
   
       
       
     def ECHO_getMD(self,item):      def ECHO_getMD(self,item):
         """Ausgabe der MD"""          """Ausgabe der MD"""
         return getattr(self,item)          return getattr(self,item)
Line 319  def manage_addECHO_resourceForm(self): Line 802  def manage_addECHO_resourceForm(self):
   
   
   
 def manage_addECHO_resource(self,id,title,label,description,content_type,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):  def manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
     """addaresource"""      """addaresource"""
   
     newObj=ECHO_resource(id,link,metalink,title,label,description,content_type,responsible,credits,weight,coords)      newObj=ECHO_resource(id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords)
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
   
Line 335  class ECHO_externalLink(Folder): Line 818  class ECHO_externalLink(Folder):
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type='ECHO_externalLink'      meta_type='ECHO_externalLink'
   
       def getTitle(self):
       """title"""
       return self.title.encode('utf-8') 
   
       def getLabel(self):
       """title"""
       return self.label.encode('utf-8') 
   
       def content_html(self):
           """template fuer content"""
           return content_html(self,'externalLink')
   
     def __init__(self,id,link,title,label,description,content_type,responsible,credits,weight,coords):      def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
   
         self.id = id          self.id = id
         """Festlegen der ID"""          """Festlegen der ID"""
Line 347  class ECHO_externalLink(Folder): Line 841  class ECHO_externalLink(Folder):
         self.title=title          self.title=title
         self.weight=weight          self.weight=weight
         self.description=description          self.description=description
         self.content_type=content_type          self.contentType=contentType
         self.responsible=responsible          self.responsible=responsible
         coordsnew=[ string.split(x,",") for x in coords]          coordsnew=[ string.split(x,",") for x in coords]
         self.coords=coordsnew          self.coords=coordsnew
Line 366  class ECHO_externalLink(Folder): Line 860  class ECHO_externalLink(Folder):
         return pt()          return pt()
           
   
     def changeECHO_externalLink(self,link,title,label,description,content_type,responsible,weight,coords=None,credits=None,RESPONSE=None):      def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
   
         """Änderung der Properties"""          """Änderung der Properties"""
       try:
           coordsnew=[ string.split(x,",") for x in coords]
       except:
           coordsnew=[]
                   
           setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)
   
         setECHO_collectionInformation(self,title,label,description,content_type,responsible,credits,weight,coords)          self.coords=coordsnew[0:]
   
           
         self.link=link          self.link=link
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
Line 383  class ECHO_externalLink(Folder): Line 880  class ECHO_externalLink(Folder):
         {'label':'Main Config','action':'ECHO_externalLink_config'},          {'label':'Main Config','action':'ECHO_externalLink_config'},
         )          )
           
       def getCredits(self):
           """Ausgabe der credits"""
           if self.credits:
               return self.credits
           else:
               return []
           
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
                   
Line 394  def manage_addECHO_externalLinkForm(self Line 898  def manage_addECHO_externalLinkForm(self
         return pt()          return pt()
   
   
 def manage_addECHO_externalLink(self,id,title,label,description,content_type,responsible,link,weight,coords=None,credits=None,RESPONSE=None):  def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
     """Add an external Link"""      """Add an external Link"""
   
     newObj=ECHO_externalLink(id,link,title,label,description,content_type,responsible,credits,weight,coords)      newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)
   
       self._setObject(id,newObj)
   
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
    
   
   class ECHO_link(ECHO_externalLink):
       """external_link"""
   
       meta_type="ECHO_link"
       
   
       def content_html(self):
           """template fuer link"""
           if hasattr(self,"link_template"):
               return content_html(self,'link')
           else:
               return content_html(self,'collection')
       
   def manage_addECHO_linkForm(self):
           """Form for external Links"""
           pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)
           return pt()
   
   
   def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
       """Add an external Link"""
   
       newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
   
Line 407  def manage_addECHO_externalLink(self,id, Line 941  def manage_addECHO_externalLink(self,id,
                   
 class ECHO_collection(Folder, Persistent, Implicit):  class ECHO_collection(Folder, Persistent, Implicit):
     """ECHO Collection"""      """ECHO Collection"""
   
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type='ECHO_collection'      meta_type='ECHO_collection'
       viewClassificationList=viewClassificationListMaster
       displayTypes=displayTypes
   
       def getViewClassification(self):
           if hasattr(self,'viewClassification'):
               return self.viewClassification
           else:
               return ""
   
       def getTitle(self):
       """title"""
       return self.title.encode('utf-8') 
   
       def getLabel(self):
       """title"""
       return self.label.encode('utf-8') 
   
   
   
       def createRessourcesFromXMLForm(self):
           """form"""
           pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)
           return pt()
   
       def createRessourcesFromXML(self,fileupload):
           """read an XML file for generating resources"""
           dom=xml.dom.minidom.parse(fileupload)
           ret="<h2>Added</h2>"
           for resource in dom.getElementsByTagName('resource'):
               link=getText(resource.getElementsByTagName('link')[0].childNodes)
               label=getText(resource.getElementsByTagName('label')[0].childNodes)
               #splitted=link.split("?")[0].split("/")
               #id=splitted[len(splitted)-1].encode('ascii')
               id=re.sub(" ","_",label).encode('ascii')
               
               ret+="<p>"+label+"</p>"
               manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","")
           return ret
       def getImageTag(self):
           """GetTag"""
           try:
               return self.imageTag
           except:
               return ""
   
       def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
           """SSS"""
           try:
               manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
               return "done"
           except:
               return None
   
       def getSecondaryLink(self):
           """secondary link"""
           try:
               return self.secondaryLink
           except:
               return ""
   
       def getSecondaryLinkTitle(self):
           """secondary link"""
           try:
               return self.secondaryLinkTitle
           except:
               return ""
           
       def getCollectionTreeXML(self):
           """Tree as XML"""
   
           def getCollection(object,depth=0):
               depth+=1
               collections=""
               for entry in object.__dict__.keys():
                   element=getattr(object,entry)
                   try:
                       if element.meta_type in ["ECHO_collection","ECHO_group"]:
                           collections+="<element name=\""+quote(element.title)+"\" url=\""+element.absolute_url()+"\">"
                           collections+=getCollection(element,depth)+"</element>\n"
                   except:
                       """nothing"""
               return collections
           
       ret="""<?xml version="1.0" encoding="utf-8" ?>"""
           return ret+"<collection>"+getCollection(self)+"</collection>"
       
       def createJavaScript(self):
           """OLD CreateJava"""
           ret=javaScriptMain
   
           dynamical="\n"
           for ob in self.getGraphicCoords():
           if ob[4][4] == "":  
               dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])
           else:
           dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])
           dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])
       ret+=javaHandler%dynamical
           return ret
   
       def createJSAreas(self):
           """create area calls for JavaScript"""
           dynamical="\n"
           for ob in self.getGraphicCoords():
           if ob[5] == "area":
               dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob[1],ob[0])
           else:
               dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob[1],ob[0])
           return dynamical
   
       def createMapHead(self):
           """create javascript include and script tags for head"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)
           return pt()
   
       def createMapImg(self):
       """generate img-tag for map"""
       bt = BrowserCheck(self)
       tag = ""
       src = self.REQUEST['URL1'] + "/overview"
       if bt.isN4:
           tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src
       else:
           tag += '<img id="overview" src="%s" />'%src
       return tag
           
       def createMapLink(self, ob, text=None):
       """generate map link"""
       bt = BrowserCheck(self)
       id = ob[1]
       link = ob[1]
       if text == None:
           text = ob[2]
       tag = ""
       if bt.isN4:
           tag += '<ilayer id="a.%s"><a onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
           tag += ">" + text + "</a></ilayer>"
       else:
           tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
           if ob[3].contentType == 'text-popup':
           tag += ' title="%s"'%ob[3].description
           tag += ">" + text + "</a>"
       return tag
   
       def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil"):
       """generate map link image, text and other stuff"""
       id = ob[1]
       link = ob[1]
       vtype = ob[5]
       ctype = ob[3].contentType
       bt = BrowserCheck(self)
       tag = ""
   
       if bt.isN4:
           tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)
           if vtype == "view point":
               rot = ob[4][4]
           tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,arrowsrc,rot)
           else:
           tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)
           if ctype == "text-popup":
               desc = ob[3].description
               tag += ' alt="%s"'%desc
           tag += ' /></a>'
           tag += '</layer>'
       else:
           tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)
           if vtype == "view point":
           rot = ob[4][4]
           if bt.isIEWin and bt.versIE > 5:
               tag += '<span id="i.%s" style="position:absolute; top:-100px; left:-100px; border-style:none; border-width=1px; filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\'%s&rot=%s\');"><img style="visibility:hidden" src="%s&rot=%s" /></span>'%(id,arrowsrc,rot,arrowsrc,rot)
           else:
               tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,arrowsrc,rot)
           else:
           if bt.isIEWin:
               tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;background:url(area_img)"'%(id)
           else:
               tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
           if ctype == "text-popup":
               desc = ob[3].description
               tag += ' title="%s"'%desc
           tag += '> </div>'
           tag += '</a>'
       return tag
   
           
     security.declarePublic('getCreditObject')      security.declarePublic('getCreditObject')
     def getCreditObject(self,name):      def getCreditObject(self,name):
         """credit id to credititem"""          """credit id to credititem"""
           try:
         return getattr(self.partners,name)          return getattr(self.partners,name)
           except:
               return ""
           
     security.declarePublic('ECHO_generateNavBar')      security.declarePublic('ECHO_generateNavBar')
     def ECHO_generateNavBar(self):      def ECHO_generateNavBar(self):
Line 437  class ECHO_collection(Folder, Persistent Line 1158  class ECHO_collection(Folder, Persistent
         return ret          return ret
           
     security.declarePublic('ECHO_rerenderLinksMD')      security.declarePublic('ECHO_rerenderLinksMD')
     def ECHO_rerenderLinksMD(self):  
         """Rerender all Links"""  
           
         for entry in self.__dict__.keys():  
             object=getattr(self,entry)  
                           
       def ECHO_rerenderLinksMD(self,obj=None):
           """Rerender all Links"""
           if not obj:
               obj = self
                           
             try:          entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
                                   
                 if object.meta_type == 'ECHO_resource':          for entry in entries:
           if entry[1].meta_type == 'ECHO_resource':
               entry[1].ECHO_getResourceMD(template="no")
               #print "rerender",entry[1].getId()
           else:
              self.ECHO_rerenderLinksMD(entry[1])
                                           
                     object.ECHO_getResourceMD(template="no")  
                                           
             except:  
                 """nothing"""  
                                   
         return "Rerenderd all links to resources in: "+self.title          return "Rerenderd all links to resources in: "+self.title
           
       security.declarePublic('ECHO_newViewerLink')
       
   
     def getCoords(self):      def getCoords(self):
         try:          try:
Line 466  class ECHO_collection(Folder, Persistent Line 1190  class ECHO_collection(Folder, Persistent
   
             return []              return []
                   
     def __init__(self,id,title,label,description,content_type,responsible,credits,weight,sortfield,coords):      def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):
         #print "CO",coords          #print "CO",coords
   
         self.id = id          self.id = id
Line 475  class ECHO_collection(Folder, Persistent Line 1199  class ECHO_collection(Folder, Persistent
         self.label = label          self.label = label
         self.title=title          self.title=title
         self.description=description          self.description=description
         self.content_type=content_type          self.contentType=contentType
         self.responsible=responsible          self.responsible=responsible
           self.imageTag=imageTag
         self.weight=weight          self.weight=weight
         self.sortfield=sortfield          self.sortfield=sortfield
         coordsnew=[ string.split(x,",") for x in coords]          coordsnew=[ string.split(x,",") for x in coords]
         self.coords=coordsnew          self.coords=coordsnew
           self.secondaryLinkTitle=secondaryLinkTitle
           self.secondaryLink=secondaryLink
       self.bgcolour=bgcolour
   
   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Main Config','action':'ECHO_collection_config'},          {'label':'Main Config','action':'ECHO_collection_config'},
         {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},          {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
         {'label':'Graphics','action':'ECHO_graphicEntry'},          {'label':'Graphics','action':'ECHO_graphicEntry'},
       {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
   
         )          )
   
       def getOverview(self):
           """overview graphics"""
           
           return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
       
       
     def ECHO_graphicEntry(self):      def ECHO_graphicEntry(self):
         """DO nothing"""          """DO nothing"""
         if 'overview' in self.aq_parent.__dict__.keys():          overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
           
       
           if overview:
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)              pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
             return pt()              return pt()
         else:          else:
Line 531  class ECHO_collection(Folder, Persistent Line 1268  class ECHO_collection(Folder, Persistent
     security.declarePublic('changeECHO_collection')      security.declarePublic('changeECHO_collection')
   
   
     def changeECHO_collection(self,title,label,description,content_type,responsible,weight,credits=None,sortfield="weight",coords=None,RESPONSE=None):      def getBgcolour(self):
         """Änderung der Properties"""          """colour"""
           if hasattr(self,'bgcolour') and not (self.bgcolour==""):
               return self.bgcolour
           else:
               return "#dddddd"
   
       def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",viewClassification=None):
           """Aenderung der Properties"""
   
           self.secondaryLink=secondaryLink
           self.secondaryLinkTitle=secondaryLinkTitle
           self.imageTag=imageTag
       self.bgcolour=bgcolour
           self.viewClassification=viewClassification
       
           if coords:
         coordsnew=[ string.split(x,",") for x in coords]          coordsnew=[ string.split(x,",") for x in coords]
               self.coords=coordsnew[0:]
           else:
               coordsnew=None
               self.coords=None
   
         setECHO_collectionInformation(self,title,label,description,content_type,responsible,credits,weight,coordsnew)          setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
       try:
           self.coords=coordsnew[0:] # HACK fehler in setECHO_collection
           except:
           """none"""
   
         self.sortfield=sortfield          self.sortfield=sortfield
   
Line 545  class ECHO_collection(Folder, Persistent Line 1304  class ECHO_collection(Folder, Persistent
                           
     security.declarePublic('index_html')      security.declarePublic('index_html')
   
     showOverview=DTMLFile('ECHO_content_overview',globals())  
           
       def showOverview(self):
           """overview"""
           if 'ECHO_overview.html' in self.__dict__.keys():
               return getattr(self,'ECHO_overview.html')()
           pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)
           return pt()
   
       security.declareProtected('View','index_html')
           
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
                   
         if 'index.html' in self.__dict__.keys():          if 'index.html' in self.__dict__.keys():
             return getattr(self,'index.html')()              return getattr(self,'index.html')()
           
         elif 'overview' in self.__dict__.keys():          elif 'overview' in self.__dict__.keys():
             return self.showOverview()              return self.showOverview()
           elif hasattr(self,'collection_index_template'):
               return self.collection_index_template()    
           elif hasattr(self,'main_index_template'):
               return self.main_index_template()    
                           
                   pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_standard.zpt').__of__(self)  
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
       def content_html(self):
           """template fuer content"""
           return content_html(self,'collection')
       
     def getCredits(self):      def getCredits(self):
         """Ausgabe der credits"""          """Ausgabe der credits"""
         if self.credits:          if self.credits:
Line 568  class ECHO_collection(Folder, Persistent Line 1342  class ECHO_collection(Folder, Persistent
         else:          else:
             return []              return []
   
       def area_img(self):
           """area image"""
       bt = BrowserCheck(self)
       if bt.isIE or bt.isN4:
           return sendFile(self, 'images/red.gif', 'image/gif')
       else:
           return sendFile(self, 'images/reda.png', 'image/png')
   
       def trans_img(self):
           """empty image"""
           return sendFile(self, 'images/trans.gif', 'image/gif')
   
       def hl_lib_js(self):
           """javascript"""
           return sendFile(self, 'js/hl_lib.js', 'text/plain')
   
       def js_lib_js(self):
           """javascript"""
           return sendFile(self, 'js/js_lib.js', 'text/plain')
   
     def getGraphicCoords(self):      def getGraphicCoords(self):
         """Give list of coordinates"""          """Give list of coordinates"""
         subColTypes=['ECHO_collection','ECHO_externalLink','ECHO_resource']          subColTypes=['ECHO_collection','ECHO_resource']
         ids=[]          ids=[]
         for entry in self.__dict__.keys():          for entrySearch in self.ZopeFind(self,obj_metatypes=subColTypes):
             object=getattr(self,entry)              object=entrySearch[1]
             try:              if hasattr(object,'coords'):
                 if object.meta_type in subColTypes:  
                     for coordtemp in object.coords:                      for coordtemp in object.coords:
                         if len(coordtemp)>3:                          if len(coordtemp)>3:
                             coord=coordtemp[0:4]                              coord=coordtemp[0:4]
                             if hasattr(object,'title'):                          label=""
                                 if not object.title=="":              vc=""
                                     ids.append([string.join(coord,", "),object.getId(),object.title])                          if hasattr(object,'label') and not object.label=="":
                               label=object.label
                           elif hasattr(object,'title') and not object.title=="":
                               label=object.title
                           else:
                               label=object.getId()
               if object.viewClassification != "":
                   vc=object.viewClassification
                                 else:                                  else:
                                     ids.append([string.join(coord,", "),object.getId(),object.getId()])                  if len(coordtemp) > 4 and coordtemp[4] != "":
                   vc="view point"
                   else:
                   vc="area"
                           ids.append([string.join(coord,", "),object.getId(),label,object,coordtemp,vc])
           return ids
       
   
   
   
       getSubCols = ECHO_helpers.getSubCols
   
   Globals.InitializeClass(ECHO_collection)
       
   def manage_addECHO_collectionForm(self):
           """Add collection form"""
           pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)
           return pt()
   
   
   def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
       """add a echo collection"""
       
   
       newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
   
       self._setObject(id,newObj)
   
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
   class ECHO_group(ECHO_collection):
       """ECHO Gruppe"""
       security=ClassSecurityInfo()
       meta_type="ECHO_group"
   
       manage_options = Folder.manage_options+(
           {'label':'Main Config','action':'ECHO_group_config'},
           {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
           {'label':'Graphics','action':'ECHO_graphicEntry'},
           )
       
       security.declareProtected('View','index_html')
       def index_html(self):
           """standard page"""
           displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
           #if (len(displayedObjects)==1) and (displayedObjects[0][1].meta_type=="ECHO_collection"): # nur ein Object dann redirect auf dieses Object
           #   return self.REQUEST.RESPONSE.redirect(displayedObjects[0][1].absolute_url())
           
           if 'index.html' in self.__dict__.keys():
               return getattr(self,'index.html')()
           
           elif 'overview' in self.__dict__.keys():
               return self.showOverview()
           elif hasattr(self,'group_index_template'):
               return self.group_index_template()
           elif hasattr(self,'collection_index_template'):
               return self.collection_index_template()    
           elif hasattr(self,'main_index_template'):
               return self.main_index_template()    
   
           pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
           pt.content_type="text/html"
           return pt()
   
       def ECHO_group_config(self):
           """Main configuration"""
           
           if not hasattr(self,'weight'):
               self.weight=""
               
           if not hasattr(self,'sortfield'):
               self.sortfield="weight"
                   
           if not hasattr(self,'coords'):
               self.coords=[]
   
           pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)
           return pt()
   
       def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
           """Änderung der Properties"""
   
           self.secondaryLink=secondaryLink
           self.secondaryLinkTitle=secondaryLinkTitle
           self.imageTag=imageTag
           self.bgcolour=bgcolour
                   self.logo=logo
                   
           if coords:
               coordsnew=[ string.split(x,",") for x in coords]
               self.coords=coordsnew[0:]
                             else:                              else:
                                 ids.append([string.join(coord,", "),object.getId(),object.getId()])              coordsnew=None
               self.coords=None
   
           setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
                                           
   
   
           self.sortfield=sortfield
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def getLogo(self):    
           """logo ausgeben"""
                   try:
                       return self.logo
             except:              except:
                 """nothing"""                      return "ECHO_groups"
   
         return ids      def content_html(self):
           """template fuer content"""
           return content_html(self,'group')
           
     def getSubCols(self,sortfield="weight"):  
   
         subColTypes=['ECHO_collection','ECHO_externalLink','ECHO_resource']  
         ids=[]  def manage_addECHO_groupForm(self):
         for entry in self.__dict__.keys():          """Add group form"""
             object=getattr(self,entry)          pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)
           return pt()
   
   
   def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
       """add a echo group"""
       
   
       newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
   
       setattr(newObj,'logo',logo)
       self._setObject(id,newObj)
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
   Globals.InitializeClass(ECHO_group)
   
   
   class ECHO_userFolder(UserFolder):
       """User folder for Intranet"""
       _domain_auth_mode=1 # Identification via domain
       meta_type="ECHO_userFolder"
       
       def authenticate(self, name, password, request):
           emergency = self._emergency_user
           if name is None:
               return None
           if emergency and name==emergency.getUserName():
               user = emergency
           else:
               user = self.getUser(name)
           if user is not None and user.authenticate(password, request):
               return user
           else:
               return None
   
       def domainSpecMatch(self,spec, request):
           host=''
           addr=''
   
           # Fast exit for the match-all case
           if len(spec) == 1 and spec[0] == '*':
           return 1
   
           if request.has_key('REMOTE_HOST'):
           host=request['REMOTE_HOST']
   
           if request.has_key('REMOTE_ADDR'):
           addr=request['REMOTE_ADDR']
   
           if request.has_key('HTTP_X_FORWARDED_FOR'):
           addr=request['HTTP_X_FORWARDED_FOR']
   
           
           if not host and not addr:
           return 0
   
           if not host:
           try:    host=socket.gethostbyaddr(addr)[0]
           except: pass
           if not addr:
           try:    addr=socket.gethostbyname(host)
           except: pass
   
   
           _host=host.split('.')
           _addr=addr.split('.')
           _hlen=len(_host)
           _alen=len(_addr)
   
           for ob in spec:
           sz=len(ob)
           _ob=ob.split('.')
           _sz=len(_ob)
   
           mo = addr_match(ob)
           if mo is not None:
               if mo.end(0)==sz:
               fail=0
               for i in range(_sz):
                   a=_addr[i]
                   o=_ob[i]
                   if (o != a) and (o != '*'):
                   fail=1
                   break
               if fail:
                   continue
               return 1
   
           mo = host_match(ob)
           if mo is not None:
               if mo.end(0)==sz:
               if _hlen < _sz:
                   continue
               elif _hlen > _sz:
                   _item=_host[-_sz:]
               else:
                   _item=_host
               fail=0
               for i in range(_sz):
                   h=_item[i]
                   o=_ob[i]
                   if (o != h) and (o != '*'):
                   fail=1
                   break
               if fail:
                   continue
               return 1
           return 0
   
   Globals.default__class_init__(ECHO_userFolder)
   
   
   
   def manage_addECHO_userFolder(self,dtself=None,REQUEST=None,**ignored):
       """add a user folder """
       f=ECHO_userFolder()
       self=self.this()
       try:    self._setObject('acl_users', f)
       except: return MessageDialog(
                      title  ='Item Exists',
                      message='This object already contains a User Folder',
                      action ='%s/manage_main' % REQUEST['URL1'])
       self.__allow_groups__=f
       if REQUEST is not None:
           REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
   
   def manage_addECHO_userFolderForm(self):
       """add a user folder form"""
       return manage_addECHO_userFolder(self)
   
   class ECHO_root(Folder,Persistent,Implicit):
       """ECHO Root Folder"""
   
       security=ClassSecurityInfo()
       
       meta_type="ECHO_root"
       
       
       def getImageTag(self):
           """needed by main_template"""
           return ""
       secondaryLink="" #needed by main_template
       secondaryLinkTitle="" #needed by main_template
       
       def getBgcolour(self):
       """hack"""
       return "#dddddd"
   
       def contentTypeSelector_HTML(self,selected=None):
           """give type selector"""
           if not selected:
               retStr="<option selected>\n"
           else:
               retStr="<option>\n"
               
           try: # erste version contentTypes exists
               for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):
                   if selected and (contentType[0]==selected):
                       retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
                   else:                
                       retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
           except:
             try:              try:
                 if object.meta_type in subColTypes:              for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):
                     ids.append(object)                  if selected and (contentType[0]==selected):
                       retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
                   else:                
                       retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
           except:
               """nothing"""
                   
       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:              except:
                 """nothing"""                  """nothing"""
         try:       return retStr
             sortfield=self.sortfield  
       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:          except:
             """nothing"""              """nothing"""
        return retStr
                           
         tmplist=[]  
         for x in ids:      def copyrightTypeSelector_HTML(self,selected=None):
             if hasattr(x,sortfield):           """give type selector"""
                 try:       if not selected:
                     x=int(x)           retStr="<option selected>\n"
        else:
            retStr="<option>\n"
            
        try: # erste version copyrightTypes exists
            for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
                if selected and (copyrightType[0]==selected):
                    retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
                else:                
                    retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
                 except:                  except:
                     """nothing"""                      """nothing"""
                 tmp=getattr(x,sortfield)       return retStr
   
               
       def patchContentType(self,obj=None):
           """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
       
   
           if not obj:
               obj = self
               
           entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
   
           for entry in entries:
                   setattr(entry[1],'contentType',entry[1].content_type)
                   #entry[1].contentType == entry[1].content_type
   
                   if entry[1].meta_type == 'ECHO_collection':
                       entry[1].patchContentType(entry[1])    
   
                   
           return "changed all contenttypes in: "+self.title
   
   
       def patchViewClassification(self,obj=None):
           """setze viewClassification heuristisch"""
   
       def checkIfArrow(obj):
           if hasattr(obj,'coords'):
               for coordtemp in obj.coords:
                   #print obj.title,len(coordtemp)
                   if (len(coordtemp)>4) and not (coordtemp[4]==''):
                       return 4
               return None
           return None
       
           if not obj:
               obj = self
               
           entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])
   
           for entry in entries:
           
           if checkIfArrow(entry[1]):
               setattr(entry[1],'viewClassification','view point')
             else:              else:
                 tmp=10000000              setattr(entry[1],'viewClassification','area')
             tmplist.append((tmp,x))  
         tmplist.sort()  
         return [x for (key,x) in tmplist]  
             
                   #entry[1].contentType == entry[1].content_type
                   
                   if entry[1].meta_type in ['ECHO_collection','ECHO_group']:
                       entry[1].patchViewClassification(entry[1])    
                   
                                   
           return "changed all contenttypes in: "+self.title
           
       def ECHO_newViewerLink(self,obj=None):
           """change links (:86 faellt weg)"""
           
 def manage_addECHO_collectionForm(self):          if not obj:
         """Add collection form"""              obj = self
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)  
         return pt()  
   
           entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
   
 def manage_addECHO_collection(self,id,title,label,description,content_type,responsible,weight,sortfield,coords="",credits=None,RESPONSE=None):          for entry in entries:
     """add a echo collection"""  
           
                   if entry[1].meta_type == 'ECHO_resource':
   
     newObj=ECHO_collection(id,title,label,description,content_type,responsible,credits,weight,sortfield,coords)                      entry[1].link=re.sub('\:86','',entry[1].link)
   
     self._setObject(id,newObj)                  else:
   
     if RESPONSE is not None:                      entry[1].ECHO_newViewerLink(entry[1])
         RESPONSE.redirect('manage_main')  
   
 class ECHO_root(Folder,Persistent,Implicit):          return "Rerenderd all links to resources in: "+self.title
     """ECHO Root Folder"""  
     meta_type="ECHO_root"  
   
     def __init__(self,id,title):      def __init__(self,id,title):
         """init"""          """init"""
Line 675  class ECHO_root(Folder,Persistent,Implic Line 1829  class ECHO_root(Folder,Persistent,Implic
                           
             for word in words:              for word in words:
                 strUrl=url%word                  strUrl=url%word
                 print "str",strUrl                  #print "str",strUrl
                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)                  retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
             str=retStr              str=retStr
         if str:          if str:
Line 686  class ECHO_root(Folder,Persistent,Implic Line 1840  class ECHO_root(Folder,Persistent,Implic
     def link2html(self,str):      def link2html(self,str):
         """link2html fuer VLP muss hier noch raus"""          """link2html fuer VLP muss hier noch raus"""
         if str:          if str:
             print str              #print str
             str=re.sub("\&","&amp;",str)              str=re.sub("\&","&amp;",str)
             dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")              dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")
             links=dom.getElementsByTagName("link")              links=dom.getElementsByTagName("link")
                           
             print "link",links              #print "link",links
             for link in links:              for link in links:
                 link.tagName="a"                  link.tagName="a"
                 ref=link.getAttribute("ref")                  ref=link.getAttribute("ref")
Line 720  class ECHO_root(Folder,Persistent,Implic Line 1874  class ECHO_root(Folder,Persistent,Implic
                   
     def getPartners(self):      def getPartners(self):
         """Get list of Partners. Presently only from a subfolder partners"""          """Get list of Partners. Presently only from a subfolder partners"""
         partnerTypes=['ECHO_partner']  
         ids=[]  
         try:  
             for entry in self.partners.__dict__.keys():  
                 object=getattr(self.partners,entry)  
                                   
                 try:          return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
                                   
                     if object.meta_type in partnerTypes:  
                         ids.append(object)  
                                           
                 except:                     
                     """nothing"""  
         except:      
             ids=[] # no partners      def getPartnersXML(self):
         return ids          """partner liste als xml""" 
           partners=self.getPartners()
           ret="""<?xml version="1.0" encoding="utf-8" ?>
       <partners>"""
           
       for partner in partners:
               ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),unicode(partner.title,'utf-8','replace'))
   
           return ret+"\n</partners>"
   
     def getCollectionTree(self):      def getCollectionTree(self):
         """get the collection tree (list of triples (parent,child, depth)"""          """get the collection tree (list of triples (parent,child, depth)"""
Line 763  class ECHO_root(Folder,Persistent,Implic Line 1918  class ECHO_root(Folder,Persistent,Implic
             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))              ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
         return ret          return ret
   
       def getResourcesHTML(self,viewerType=None,filter=None):
           """gebe all ressourcen aus"""
   
           def sortHTML(x,y):
               return cmp(x[1].title,y[1].title)
           
           ret="""<html><body><h2>Resources in ECHO</h3>"""
           
           resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
           ret+="""<h3>Found %i resources</h3>"""%len(resources)
           resources.sort(sortHTML)
           for resource in resources:
               echo_url=resource[1].absolute_url()
               
               if hasattr(resource[1],'title'):
                   title=resource[1].title
               else:
                   title="None"
               if filter:
                   if re.search(filter,title):
                       ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
               else:
                   ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
   
           ret +="""\n</body></html>"""
           
           #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")
           #self.REQUEST.RESPONSE.write(ret)
               return ret
       
       def getResourcesXML(self,viewerType=None,filter=None):
           """gebe all ressourcen aus"""
           ret="""<?xml version="1.0" ?>
                    <index>"""
           for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
   
               echo_url=resource[1].absolute_url()
               if hasattr(resource[1],'link'):
                   viewer_url=resource[1].link
               else:
                   viewer_url="NO URL"
               if filter:
                   if re.search(filter,viewer_url):
                       ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
               else:
                   ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
           ret +="""\n</index>"""
           
           self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
           self.REQUEST.RESPONSE.write(ret)
   
       def getFullTextsXML(self,viewerType=None,filter=None):
           """gebe all ressourcen aus"""
           ret="""<?xml version="1.0" ?>
                    <index>"""
           for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
   
               echo_url=resource[1].absolute_url()
               if resource[1].getFullTextXML(noredirect="yes"):
                   if hasattr(resource[1],'link'):
                       viewer_url=echo_url+"/getFullTextXML"
                   else:
                       viewer_url="NO URL"
                   if filter:
                       if re.search(filter,viewer_url):
                           ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
                   else:
                       ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
           ret +="""\n</index>"""
           print ret
                   
           self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
           self.REQUEST.RESPONSE.write(ret)
                   
 def manage_addECHO_root(self,id,title,RESPONSE=None):  def manage_addECHO_root(self,id,title,RESPONSE=None):
     """Add an ECHO_root"""      """Add an ECHO_root"""
Removed from v.1.14  
changed lines
  Added in v.1.89

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