[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.77 and 1.310.2.12

version 1.77, 2004/05/10 15:27:32 version 1.310.2.12, 2013/08/05 08:20:10
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 produc 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.
   
 class ECHO_collection is the basis class for an ECHO collection.  class ECHO_collection is the basis class for an ECHO collection.
Line 9  class ECHO_externalLink contains informa Line 9  class ECHO_externalLink contains informa
   
   
 """  """
   
        
   import urlparse
 import string  import string
   import tempfile
   import zipfile
 import re  import re
 import os  import os,shutil
 import OFS.Image  import OFS.Image
 from types import *  from types import *
   from OFS.Cache import Cacheable
 from OFS.Image import Image  from OFS.Image import Image
 from Globals import DTMLFile  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 Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate,manage_addPageTemplate
 from Globals import Persistent, package_home  from Globals import Persistent, package_home
 from Acquisition import Implicit  from Acquisition import Implicit
 from ECHO_helpers import displayTypes  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon
   import ECHO_helpers
   from Acquisition import aq_parent
   try:
       from Products.MetaDataProvider.MetaDataClient import MetaDataClient
   except:
       print "no metadataclient"
   import urllib
   import urllib2
   import cgi
   import smtplib
   import time
   #from Ft.Xml.Domlette import NonvalidatingReader
   #from Ft.Xml.Domlette import PrettyPrint, Print
   #from Ft.Xml import EMPTY_NAMESPACE
   #
   #import Ft.Xml.XPath
   import cStringIO
   
   import sys
   import logging
   
 try:  try:
     from psycopg import libpq      from psycopg import libpq
 except:  except:
Line 39  import xml.dom.minidom Line 69  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  import ECHO_helpers
   from ECHO_helpers import *
   
 #List of different types for the graphical linking viewer  
 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:              try:
                 if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):   from ECHO_language import *
                     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:              except:
                 diffs[self.getFieldTag(tags,field)]=0      print "no echo_language"
                 print "EX",field      class ECHO_language:
         return diffs          """ leere Klasse"""
           pass
           
 def content_html(self,type):  from ECHO_movie import *
         """template fuer content"""  #import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
         #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])  import xmlrpclib
         #  
         #if templates:  
         #    return templates[0][1]()  
   
         try:  import logging
             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):  from ECHO_root  import ECHO_root
     """Einzelfeld in Liste umwandeln"""  
     if type(field)==StringType:  
         return [field]  
     else:  
         return field  
       
 def getText(nodelist):  
   
     rc = ""  
     for node in nodelist:  
         if node.nodeType == node.TEXT_NODE:  
            rc = rc + node.data  
     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  
   
   #ersetzt logging.info
   def logger(txt,method,txt2):
       """logging"""
       logging.info(txt+ txt2)
   
 def writeMetadata(url,metadict):  
     """Einlesen der Metadaten und und erstellen des geänderten XML file"""  
   
     try:  def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs=""):
         geturl=""  
         for line in urllib.urlopen(url).readlines():  
             geturl=geturl+line  
                   
           """Allegemeine Informationen zu einer ECHO Collection"""
                   
     except:          self.label = label
         return (None,"Cannot open: "+url)          self.title=title
           self.description=description
           self.contentType=contentType
           self.responsible=responsible
           self.credits=toList(credits)
           self.weight=weight
   
     try:  import ECHO_resource
         dom=xml.dom.minidom.parseString(geturl)  from ECHO_resource import manage_addECHO_resource
     except:  
         return (None,"Cannot parse: "+url+"<br>"+geturl)  
   
     metanodes=dom.getElementsByTagName('bib')  class ECHO_resource(ECHO_resource.ECHO_resource):
       """depricated use class in ECHO_resource.py"""
   
     if not metanodes:  
         metanodes=dom.getElementsByTagName('archimedes')  
   
     metanode=metanodes[0]  class ECHO_partner(Image,Persistent,ECHO_basis):
       """ECHO Partner"""
   
     for metaData in metadict.keys():      meta_type="ECHO_partner"
         print metaData,metanode  
         try:  
             nodeOld=metanode.getElementsByTagName(metaData)  
         except:  
             nodeOld=None  
                           
         if nodeOld:      def __init__(self, id, title,url, file, copyrightType, person, email, country, color, content_type='', precondition=''):
             metanode.removeChild(nodeOld[0]).unlink()          self.__name__=id
         else:          self.title=title
             # try also old writing rule - instead of _:          self.url=url
             try:          self.person=person
                 nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))          self.email=email
             except:          self.country=country
                 nodeOld=None          self.color=color
           self.precondition=precondition
           self.copyrightType=copyrightType
           data, size = self._read_data(file)
           content_type=self._get_content_type(file, data, id, content_type)
           self.update_data(data, content_type, size)
                                   
             if nodeOld:      manage_options = Image.manage_options+(
                 metanode.removeChild(nodeOld[0]).unlink()          {'label':'Partner Information','action':'ECHO_partner_config'},
           )
   
         metanodeneu=dom.createElement(metaData)  
         metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf8"))  
         metanodeneu.appendChild(metanodetext)  
         metanode.appendChild(metanodeneu)  
   
       def changeECHO_partner(self,url,copyrightType,person, email, country, color, RESPONSE=None):
           """Change main information"""
           self.url=url
           self.person=person
           self.email=email
           self.country=country
           self.color=color
           self.copyrightType=copyrightType
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
           
     return dom.topxml().encode('utf-8')  
   
 def readMetadata(url):  
     """Methode zum Auslesen der Metadateninformation zu einer Resource  
     Vorerst noch Typ bib"""  
           
     metadict={}      def ECHO_partner_config(self):
     try:          """Main configuration"""
         geturl=""          if not hasattr(self,'url'):
         for line in urllib.urlopen(url).readlines():              self.url=""
             geturl=geturl+line          pt=zptFile(self, 'zpt/ChangeECHO_partner.zpt')
           return pt()
                   
                   
     except:  manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
         return (None,"Cannot open: "+url)                               Kind='ECHO_partner',kind='ECHO_partner')
   
     try:  
         dom=xml.dom.minidom.parseString(geturl)  
     except:  
         return (None,"Cannot parse: "+url+"<br>"+geturl)  
   
     metanode=dom.getElementsByTagName('bib')  
     metadict['bib_type']='Book'  
     if len(metanode)==0:  
         metanode=dom.getElementsByTagName('archimedes')  
         metadict['bib_type']='Archimedes'  
         #print "HELLO"  
                   
     if not len(metanode)==0:      def manage_addECHO_partner(self, id, url, person, email, country, color, file=None, copyrightType='', title='', precondition='', content_type='',
         metacontent=metanode[0].childNodes                      REQUEST=None):
       """
       Add a new ECHO_partner object.
           
         try:      Creates a new ECHO_partner object 'id' with the contents of 'file'.
             metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)      Based on Image.manage_addImage
         except:      """
             """nothing"""  
                   
         for node in metacontent:      id=str(id)
             try:      title=str(title)
                 metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)      content_type=str(content_type)
             except:      precondition=str(precondition)
                 """nothing"""  
   
       id, title = OFS.Image.cookId(id, title, file)
   
     return metadict,""      self=self.this()
           
       # First, we create the image without data:
       self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, color, content_type, precondition))
   
 def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):      # Now we "upload" the data.  By doing this in two steps, we
       # can use a database trick to make the upload more efficient.
       if file:
           self._getOb(id).manage_upload(file)
       if content_type:
           self._getOb(id).content_type=content_type
   
         """Allegemeine Informationen zu einer ECHO Collection"""      if REQUEST is not None:
           try:    url=self.DestinationURL()
           except: url=REQUEST['URL1']
           REQUEST.RESPONSE.redirect('%s/manage_main' % url)
       return id
   
   class ECHO_locale(ZopePageTemplate):
           """localisierung"""
   
         self.viewClassification=viewClassification          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          self.label = label
               # default content
               if not text:
                   text = open(self._default_content_fn).read()
                   content_type = 'text/html'
               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.title=title
         self.description=description                  self.label=label
         self.contentType=contentType                  if not text is None:
         self.responsible=responsible                          if content_type is None:
         self.credits=toList(credits)                              content_type = self.content_type
         self.weight=weight                          self.pt_edit(text, content_type)
   
         coords=[]                  if RESPONSE is not None:
         #coordinates of for rectangles                          RESPONSE.redirect('manage_main')
   
         #print "cs", coordstrs  
         if coordstrs:  
             for coordstr in coordstrs:  
                 #print "cs", coordstr  
                 try:  
                     temco=coordstr.split(",")  
                 except:  
                     temco=[]  
                 #temco.append(angle)  
                 coords.append(temco)  
   
   def manage_addECHO_localeForm(self):
            """Form for adding"""
            pt=zptFile(self, 'zpt/AddECHO_localeForm.zpt')
            return pt()
   
         self.coords=coords[0:]  def manage_addECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
           """add echo locale"""
                           
           id="locale_"+lang
   
 class scientificClassification(SimpleItem,Persistent,Implicit):          self._setObject(id, ECHO_locale(id,lang,title,label,text,content_type))
     """outdated will be deleeted in the next versions: subclass"""          if RESPONSE is not None:
     security=ClassSecurityInfo()                  RESPONSE.redirect('manage_main')
           
     def __init__(self,context,science,practice):  
         self.context=context  
         self.science=science  
         self.practice=practice  
         self.id="scientific_Classification"  
           
     security.declarePublic('get_context')  
     def get_context(self):  
         return self.context  
       
     security.declarePublic('get_science')  
     def get_science(self):  
         return self.science  
           
     security.declarePublic('get_practice')  
     def get_practice(self):  
         return self.practice  
           
   class ECHO_copyright(Folder,ECHO_basis):
           """Copyright informationen"""
           meta_type="ECHO_copyright"
                                   
 class scientificInformation(Folder,Persistent,Implicit):  
     """outdated will be deleted in the next versions: subclass scientificInformation"""  
     security=ClassSecurityInfo()  
           
           
           def __init__(self,id,title,copyrights):
                   """init"""
                   self.title=title
                   self.id=id
                   self.copyrights=copyrights[0:]
           
     def __init__(self,source_type,period):          def getCopyrights(self):
                   """return coyprights"""
                   return self.copyrights
   
         self.id="scientific_Information"          manage_options = Folder.manage_options+(
         self.source_type=source_type                  {'label':'Main Config','action':'ECHO_copyright_configForm'},
         self.period=period                  )
                   
   
           def ECHO_copyright_configForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_copyright')
                   pt.content_type="text/html"
                   return pt()
   
     security.declarePublic('get_source_type')          def ECHO_copyright_config(self,title,RESPONSE=None):
     def get_source_type(self):                  """change"""
         return self.source_type                  self.title=title
                   self.copyrights=[]
                   self.copyrights=getCopyrightsFromForm(self,self.REQUEST.form)[0:]
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
                   
   def manage_addECHO_copyrightForm(self):
       """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_copyright.zpt')
       return pt()
   
   def manage_addECHO_copyright(self, id,title,RESPONSE=None):
           """add the copyright"""
   
           meta_type="ECHO_copyright"
           
           #first generate copyrights as list of tripels (mediaType,partner,copyrightType)
           
     security.declarePublic('get_period')  
     def get_period(self):  
         return self.period  
   
 class ECHO_layoutTemplate(ZopePageTemplate):  
           self._setObject(id, ECHO_copyright(id, title,getCopyrightsFromForm(self,self.REQUEST.form)))
   
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
           
   class ECHO_layoutTemplate(ZopePageTemplate,ECHO_basis):
     """Create a layout Template for different purposes"""      """Create a layout Template for different purposes"""
   
     meta_type="ECHO_layoutTemplate"      meta_type="ECHO_layoutTemplate"
Line 301  class ECHO_layoutTemplate(ZopePageTempla Line 315  class ECHO_layoutTemplate(ZopePageTempla
     def __init__(self, id, text=None, content_type=None,EchoType=None):      def __init__(self, id, text=None, content_type=None,EchoType=None):
         self.id = str(id)          self.id = str(id)
   
   
   
         self.ZBindings_edit(self._default_bindings)          self.ZBindings_edit(self._default_bindings)
         if text is None:          if text is None:
             self._default_content_fn = os.path.join(package_home(globals()),              self._default_content_fn = os.path.join(package_home(globals()),'zpt','ECHO_%s_template_standard.zpt'%EchoType)
                                                'zpt/ECHO_%s_template_standard.zpt'%EchoType)  
             text = open(self._default_content_fn).read()              text = open(self._default_content_fn).read()
           if content_type is None:
               content_type = self.content_type
         self.pt_edit(text, content_type)          self.pt_edit(text, content_type)
   
           
         """change form"""  
   
   
 def manage_addECHO_layoutTemplateForm(self):  def manage_addECHO_layoutTemplateForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_layoutTemplate.zpt').__of__(self)      pt=zptFile(self, 'zpt/AddECHO_layoutTemplate.zpt')
     return pt()      return pt()
   
 from urllib import quote  
   
   
 def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):  def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
     "Add a Page Template with optional file content."      "Add a Page Template with optional file content."
Line 361  def manage_addECHO_layoutTemplate(self, Line 369  def manage_addECHO_layoutTemplate(self,
     REQUEST.RESPONSE.redirect(u+'/manage_main')      REQUEST.RESPONSE.redirect(u+'/manage_main')
     return ''      return ''
   
 class ECHO_resource(Folder):  class ECHO_fullText(ZopePageTemplate,ECHO_basis,ECHO_language):
     """ECHO Ressource"""          """echo fulltext in xml"""
     meta_type='ECHO_resource'  
   
     viewClassificationList=viewClassificationListMaster          meta_type="ECHO_fullText"
   
     getSubCols = ECHO_helpers.getSubCols  
     def getTitle(self):  
     """title"""  
     return self.title.encode('utf-8')   
   
     def getLabel(self):          def getPage(self,nr='1'):
     """title"""                  """get page n"""
     return self.label.encode('utf-8')                   #return self().encode('latin-1','ignore')
                   try:
                      dom=xml.dom.minidom.parseString(self())
                   except:
                      dom=xml.dom.minidom.parseString(self.utf8ify(self()))
                   pages=dom.getElementsByTagName('page')
   
                   return pages[int(nr)-1].toxml()
           
   # Product registration and Add support
   manage_addECHO_fullTextForm = PageTemplateFile(
       'zpt/AddECHO_fullText.zpt', globals())
   
   def manage_addECHO_fullText(self, id, title=None, text=None,
                              REQUEST=None, submit=None):
       "Add a Page Template with optional file content."
   
       id = str(id)
       if REQUEST is None:
           self._setObject(id, ECHO_fullText(id, text))
           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_fullText(id)
           else:
               zpt = ECHO_fullText(id, file, headers.get('content_type'))
   
           self._setObject(id, zpt)
   
           try:
               u = self.DestinationURL()
           except AttributeError:
               u = REQUEST['URL1']
   
           if submit == " Add and Edit ":
               u = "%s/%s" % (u, urllib.quote(id))
           REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
   
   
   
   class ECHO_externalLink(Folder,ECHO_basis):
       """Link zu einer externen Ressource"""
       security=ClassSecurityInfo()
       meta_type='ECHO_externalLink'
   
       security.declarePublic('content_html')
     def content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content"""
         return content_html(self,'resource')          ret= ECHO_basis.content_html(self,'externalLink')
           
     def getViewClassification(self):          if type(ret) is StringType:
         if hasattr(self,'viewClassification'):              return ret.decode('utf-8')
             return self.viewClassification  
         else:          else:
             return ""             return ret
                   
     def getCredits(self):  
         """Ausgabe der credits"""  
         if self.credits:  
             return self.credits  
         else:  
             return []  
           
     def __init__(self,id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords):      
       def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType):
   
         self.id = id          self.id = id
         """Festlegen der ID"""          """Festlegen der ID"""
                   
           self.credits=toList(credits)
         self.label = label          self.label = label
         self.link= link          self.link= link
         self.metalink=metalink  
         self.title=title          self.title=title
         self.weight=weight          self.weight=weight
         self.credits=toList(credits)  
         self.description=description          self.description=description
         self.contentType=contentType          self.contentType=contentType
         self.responsible=responsible          self.responsible=responsible
           
         if coords:  
             coordsnew=[ string.split(x,",") for x in coords]              coordsnew=[ string.split(x,",") for x in coords]
         else:  
             coordsnew=[]  
           
         self.coords=coordsnew          self.coords=coordsnew
           self.linkType = linkType        # Linktypen 'otherPresentation','external'
   
   
     def getCoords(self):      def ECHO_externalLink_config(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"""          """Main configuration"""
         retList=[]  
         if hasattr(self,'coords'):  
             for x in self.coords:  
             if len(x)>1:  
                 retList.append(string.join(x,","))  
         return retList  
   
           if not hasattr(self,'weight'):
               self.weight=""
           if not hasattr(self,'coords'):
           
               self.coords=['']
   
     def getContentType(self):  
         try:  
             return self.contentType  
         except:  
             return ""  
   
     def getCopyrightType(self):          pt=zptFile(self, 'zpt/ChangeECHO_externalLink.zpt')
         try:          return pt()
             return self.copyrightType      
         except:  
             return ""      def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
           """Aenderung der Properties"""
           setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
   
           self.link=link
           self.linkType = linkType
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
               
       def getLinkType(self):
           """ return linkType """
           if hasattr(self,"linkType"):
                   return self.linkType
           else :
                   return 'otherPresentation'
   
       def setLinkType(self,type):
           """ set linkType """
           self.linkType = type
   
     def getRenderingType(self):      def checkLink(self):
           """ returns tuple (isWorking,Error) """        
         try:          try:
             return self.renderingType              urllib2.urlopen(self.link)
               return (True, '')
           except urllib2.HTTPError, e:
               return (False, e.code)
           except urllib2.URLError, e:
               return (False, str(e.reason))
         except:          except:
             return ""              return (False, 'unknown Error')
   
     def ECHO_resource_config(self):  
         """Main configuration"""  
   
         if not hasattr(self,'weight'):      manage_options = (
             self.weight=""          {'label':'Main Config','action':'ECHO_externalLink_config'},
           {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
           )+Folder.manage_options
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)  
         return pt()  
           
       def index_html(self):
           """standard page"""
   
     def ECHO_resource_config_main(self):          return self.REQUEST.RESPONSE.redirect(self.link)
         """Main configuration"""  
   
         if not hasattr(self,'weight'):  
             self.weight=""  
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)  def manage_addECHO_externalLinkForm(self):
           """Form for external Links"""
           pt=zptFile(self, 'zpt/AddECHO_externalLinkForm.zpt')
         return pt()          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):  def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
         """Main configuration"""      """Add an external Link"""
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)      newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
         return pt()  
   
     def ECHO_resource_config_metadata(self):      self._setObject(id,newObj)
         """Main configuration"""  
   
     if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):      if RESPONSE is not None:
         self.metaDataHash={}          RESPONSE.redirect('manage_main')
         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()  
   
   class ECHO_link(ECHO_externalLink):
           """external_link"""
   
           meta_type="ECHO_link"
           
           manage_options = ECHO_externalLink.manage_options+(
                   {'label':'add links config','action':'ECHO_link_addLinksForm'},
                   )
   
     def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):          def getMDValueSimpleSearchField(self):
         """Änderung der Properties"""            """returns value for simple search"""
     self.resourceID=resourceID            return " ".join([self.getTitle(),self.getDescription()])
     self.title=title  
     self.label=label  
     self.description=description  
   
     self.contentType=contentType          def ECHO_link_addLinksForm(self):
     self.renderingType=renderingType              """Main configuration"""
     self.weight=weight  
           
         self.link=link              pt=zptFile(self, 'zpt/ChangeECHO_link_addLinks.zpt')
         self.metalink=metalink              return pt()
                   
           def ECHO_link_addLinks(self,addLinks,RESPONSE):
               """add links"""
               self.addLinks=addLinks
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
           def content_html(self):
                   """template fuer link"""
   
     def changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):  
         """Änderung der Properties - coords"""  
   
     try:                          if hasattr(self,"link_template"):
             coordsnew=[ string.split(x,",") for x in coords]                          ret=ECHO_basis.content_html(self,'link')
         except:  
         coordsnew=[]      
   
     self.coords=coordsnew[0:]                  else:
     self.viewClassification=viewClassification                          ret=ECHO_basis.content_html(self,'collection')
                   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
     def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):                  #return ret
         """Änderung der Properties"""                  return ret
     self.credits=credits  #            
     self.responsible=responsible  #            
     self.copyrightType=copyrightType  #                try:
   #                    return ret.decode('utf-8')
   #                except:
   #                    try: 
   #                        return ret.decode('latin-1')
   #                    except:
   #                
   #                        return ret
   #        
           def getCopyrightsHTML(self):
               """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
                   
         if RESPONSE is not None:              if hasattr(self,'copyrightModel'):
             RESPONSE.redirect('manage_main')                      obj=self.copyrightModel
                       
               else:
                       return "ERROR"
               ret=[]
               
               for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
   
   
     def changeECHO_resource_metadata(self,RESPONSE=None):  
         """change metadata"""  
         tags=self.findTagsFromMapping(self.contentType)  
         self.OSAS_meta={}  
         for field in tags[1]:  
             try:              try:
                 self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]                          if hasattr(self.copyrightTypes,copyright[2]):
                 self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]                               copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
                                link="copyrightTypes/"+copyright[2]+'/copyright.html'
                           else:
                                copyrightTypeObj=getattr(obj,copyright[2])
                                link="copyrightModel/"+copyright[2]+'/copyright.html'
                                
                           label=copyrightTypeObj.label
                           url=getattr(copyrightTypeObj, 'url', '')
                               
                           if url!='':
                                    ret.append((url,copyright[0],copyright[1],copyright[2],label))
                           else:
                                   if hasattr(copyrightTypeObj, 'copyright.html'):
                                        ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
                                   else:
                                        ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
             except:              except:
                 """nothing"""                  """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()              return ret
                   
         if RESPONSE is not None:          def getInstitutionsHTML(self):
             RESPONSE.redirect('manage_main')                  """gibt Liste der foerdernden Institutionen aus"""
                   
                   if hasattr(self,'support'):
                           obj=self.support
                           ret=obj.getSupporter()
                           return ret
                   else:
                           return ''
   
           def getOwnerOriginalsHTML(self):
                  """gibt Liste der foerdernden Institutionen aus"""
   
     def newMetaXML(self):                 if hasattr(self,'ownerOriginal'):
         """new index.meta"""                         obj=self.ownerOriginal
         self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')                         ret=obj.getOwner()
         return writeMetadata(self.metalink,self.OSAS_meta)                         return ret
                  else:
                          return ''
       
           def getDigiCopyByHTML(self):
                  """gibt Liste der foerdernden Institutionen aus"""
   
                  if hasattr(self,'digiCopyBy'):
                          obj=self.digiCopyBy
                          ret=obj.getDigiCopyBy()
                          return ret
                  else:
                          return ''
           
     def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):          def index_html(self):
         """Änderung der Properties"""                  """standard link"""
                   if self.link:
                    splitted=self.link.split("?")
                    if len(splitted)>1:
                           params=cgi.parse_qs(splitted[1])
                   
     try:                                  for x in params.keys():
             coordsnew=[ string.split(x,",") for x in coords]                                  if type(params[x]) is ListType:
         except:                                          params[x]=params[x][0]
         coordsnew=[]      
                   
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)  
     self.viewClassification=viewClassification                   else:
         self.coords=coordsnew[0:]                          params={}
         self.link=link                  
         self.metalink=metalink                   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):
           """Form for external Links"""
           pt=zptFile(self, 'zpt/AddECHO_linkForm.zpt')
           return pt()
   
   
   def manage_addECHO_link(self,id,title,label,description="",contentType="",responsible="",link="",weight="",coords=[],credits=None,linkType="external",RESPONSE=None):
       """Add an external Link"""
   
       newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
   
       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')
                           
                           
     manage_options = Folder.manage_options+(  class ECHO_collection(CatalogAware, Folder, Persistent, Implicit, Cacheable,ECHO_basis):
         {'label':'Main Config','action':'ECHO_resource_config_main'},      """ECHO Collection"""
     {'label':'Change Credits & Copyright','action':'ECHO_resource_config_credits'},  
     {'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):      management_page_charset="utf-8"
         """overview graphics"""      security=ClassSecurityInfo()
       meta_type='ECHO_collection'
       default_catalog='resourceCatalog'
                   
         return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]      rootMetaTypes = ['ECHO_root', 'ECHO_main', 'ECHO_nav']
   
     def ECHO_graphicEntry(self):  #    viewClassificationList=viewClassificationListMaster
         """DO nothing"""      displayTypes=displayTypes
         overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])  
         if overview:       path="/mpiwg/online/permanent/shipbuilding"
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)  
       def getSection(self, crumbs=None):
           """returns the current section name"""
           # use breadcrumbs if available
           if crumbs is not None and len(crumbs) > 0:
               return crumbs[0][2].getId()
       
           p = self
           sec = None
           # descend parents to the root (and remember the last id)
           while p is not None and p.meta_type not in self.rootMetaTypes:
               sec = p.getId()
               p = aq_parent(p.context)
        
           return sec
       
       def getSubSection(self, crumbs=None):
           """returns the current subsection name"""
           # use breadcrumbs if available
           if crumbs is not None and len(crumbs) > 1:
               return crumbs[1][2].getId()
       
           p = self
           sec = None
           subsec = None
           # descend parents to the root (and remember the last id)
           while p is not None and p.meta_type not in self.rootMetaTypes:
               subsec = sec
               sec = p.getId()
               p = aq_parent(p.context)
             
           return subsec
       
       
       def getCrumb(self):
           """returns breadcrumb for this object"""
           return ECHO_helpers.getCrumb(self)
   
       def getHierCrumbs(self):
           """returns a list of hierarchical breadcrumbs from self to the ECHO_root"""
           return ECHO_helpers.getHierCrumbs(self)
   
       
       def exportImportObjects_html(self,RESPONSE):
           """ImportObject"""
           pt=zptFile(self, 'zpt/exportImportObjects.zpt')
           pt.content_type="text/html"
             return pt()              return pt()
         else:  
             return "NO OVERVIEW GRAPHICS"  
   
     def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):      def importObjects_html(self,RESPONSE):
         """Enter coords"""          """ImportObject"""
         coords=self.coords          pt=zptFile(self, 'zpt/importObjects.zpt')
         temco=coordstr.split(",")          pt.content_type="text/html"
         temco.append(angle)          return pt()
         coords.append(temco)  
                   
         self.coords=coords[0:]      def importObjects(self,zfile,RESPONSE=None,REQUEST=None):
           """import object from file"""
   
         if RESPONSE is not None:          zf=zipfile.ZipFile(zfile,"r")
             RESPONSE.redirect('ECHO_graphicEntry')          tmpdir=tempfile.mkdtemp() # create tempdir
           ret=None
           
           for name in zf.namelist():
                  ds,fn=tempfile.mkstemp()
                  tf=file(fn,"w")
                  x=zf.read(name)
                  tf.write(x)
                  tf.close()
                  try:
                      self._importObjectFromFile(fn,set_owner=1)
                  except:
                      if not ret:
                          ret=""
                      ret+="Cannot import: %s (Already existing?)<br>"%name
              os.close(ds)
                  os.remove(fn)
   
           zf.close()
   
           if ret:
               return """<html><body>%s</body></html>"""%ret
           if RESPONSE:
               RESPONSE.redirect(self.absolute_url())
   
       def exportObjects_html(self,RESPONSE):
           """Export objects"""
   
     def isDefinedInThisSet(self,fields,field):          pt=zptFile(self, 'zpt/exportObjects.zpt')
         """checks if field is defined in fields"""          pt.content_type="text/html"
         if (fields[0].has_key(field)) and not (fields[0][field]==""):          return pt()
             return 1  
         else:  
                       
             return 0      def exportObjects(self,ids,RESPONSE=None):
           """export objects with type id"""
           if not (type(ids) is ListType):
               ids=[ids]
                   
     def getFieldLabel(self,fields,field):          tmpdir=tempfile.mkdtemp() # create tempdir
         """get labels"""          objs=self.ZopeFind(self,obj_ids=ids)
         try:          tmpfile=tempfile.mkstemp()[1]
             ret =fields[0][field]  
             if ret == "":  
                 return field  
             else:  
                 return ret  
         except:  
             return field  
   
           zf=zipfile.ZipFile(tmpfile,"w")
           for obj in objs:
   
               f = os.path.join(tmpdir, '%s.zexp' %obj[0])
               #print E.absolute_url()
   
     def getFieldTag(self,fields,field):              obj[1]._p_jar.exportFile(obj[1]._p_oid, f)
         """get labels"""  
         try:              zf.write(f,obj[0])
             ret =fields[0][field]          
             if ret == "":          zf.close()
                 return field          shutil.rmtree(tmpdir)
           if RESPONSE:
               RESPONSE.setHeader("Content-Type","application/octet-stream")
               len=os.stat(tmpfile)[6]
               RESPONSE.setHeader("Content-Length",len)
               RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"export.zip")
               fh=file(tmpfile)
               for x in fh.read():
                   RESPONSE.write(x)
               fh.close()
               
       def getMDValueSimpleSearchField(self):
             """returns value for simple search"""
             return " ".join([self.title,self.description])
                                
       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:              else:
                 return ret                                      root=None
         except:                      else:
             return field                              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 getFieldValue(self,field):      def localize(self,REQUEST,RESPONSE):
         """get value"""              """localize"""
     #print field              for key in REQUEST.form.keys():
         try:                      splitted=key.split("!")
           
             ret=self.metaDataHash[field]                      if splitted[0]=="" or splitted[0]=="en" or splitted[0]=="title" or splitted[0]=="label":
             if ret == "":                              if splitted[0]=="en":
                 return None                                      setattr(self.locale_en,splitted[1],REQUEST.form[key])
             else:              else:
                 return ret                                      setattr(self,splitted[0],REQUEST.form[key])
         except:                      else:
             return None                              obj=getattr(self,splitted[0])
   
     def findLabelsFromMapping(self,referenceType):                              if obj.meta_type=="ECHO_mapText":
         """gib hash mit label -> generic zurueck"""                                      if splitted[1]=="en":
         self.referencetypes=self.ZopeFind(self.standardMD)                                              obj.locale_en.pt_edit(REQUEST.form[key],obj.locale_en.content_type)
     #print "RT",referenceType                                      else:
                                               obj.pt_edit(REQUEST.form[key],obj.content_type)
                               else:
                                       text=obj.ZopeFind(obj,obj_metatypes=['ECHO_mapText'])
                                       if splitted[1]=="en":
           
         bibdata={}                                              text[0][1].locale_en.pt_edit(REQUEST.form[key],text[0][1].locale_en.content_type)
         retdata={}                                      else:
         fieldlist=self.standardMD.fieldList                                              text[0][1].pt_edit(REQUEST.form[key],text[0][1].content_type)
               if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
                   
     for referenceTypeF in self.referencetypes:  
         #print referenceTypeF[1].title,referenceType      
         if referenceTypeF[1].title == referenceType:  
             #print "OK"  
             bibdata[referenceTypeF[1].title]=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):      def getRDF(self,urn=None):
         """gib hash mit label -> generic zurueck"""              """rdf of the collection"""
         self.referencetypes=self.ZopeFind(self.standardMD)  
           
               contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
           
         bibdata={}              ret=getRDFDescription(self,self.absolute_url(),urn=urn)
         retdata={}  
         fieldlist=self.standardMD.fieldList  
                   
     for referenceTypeF in self.referencetypes:              if not urn:
                       urn=self.absolute_url()
           
         if referenceTypeF[1].title == referenceType:               li="""<rdf:li rdf:resource="%s" />\n"""
             bibdata[referenceTypeF[1].title]=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  
   
               for content in contents:
           try:
                       ret+=content[1].getRDF()+"\n"
                   except:
               logging.error("getrdf: "+repr(content[1].getRDF()))
               try:
                   ret+=self.unicodify(content[1].getRDF())+"\n"
               except:
               logging.error("--still cannot do it")
                   ret+=repr(content[1].getRDF())+"\n"
               ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
               for content in contents:
                       nurn=content[1].absolute_url()
                       ret+=li%nurn
               return ret+"</rdf:Seq>"
           
           
       def getExportCollectionsAsJSON(self,metatypes=['ECHO_resource'],REQUEST=None):
           import json
           ret = self.getExport(metatypes=metatypes)
                           
     def ECHO_getResourceMD(self,template="yes"):          if REQUEST:
         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""                  REQUEST.response.setHeader("Content-type", "text/json; charset=utf-8")
         (metadict, error)=readMetadata(self.metalink)  
   
           return json.dumps(ret)
   
       def getExport(self,metatypes=['ECHO_resource'],REQUEST=None):
   
         if not error=="": #Fehler beim Auslesen des Metafiles              """JSON export collection content"""
         return "ERROR:",error              import json
               ret={}
               #contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
               contents=self.ZopeFind(self,obj_metatypes=metatypes)
           
               ret['description']=self.getDescription();
               ret['title']=self.getTitle();
               ret['label']=self.getLabel();
               ret['content']=[]
               ret['echo_path']=self.absolute_url().replace(self.echo_pages.absolute_url(),'')
   
     if not (metadict['bib_type']==self.contentType):  
         self.REQUEST.SESSION['contentStorage']=metadict['bib_type']  
         self.REQUEST.SESSION['contentZope']=self.contentType  
   
         return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()              for content in contents:
                   
         self.REQUEST.SESSION['metadict']=metadict                  ret['content'].append(content[1].getDRI(type="mpiwg"))
   
     self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)              return ret
   
                   
         if template=="yes":  
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)  
             return pt()  
   
       def getDRI(self,type="escidoc"):
           """sofar cho collections don't have dris
           therefore return the path"""
   
           return self.absolute_url().replace(self.echo_pages.absolute_url(),'')
           
           
     def ECHO_getMD(self,item):  
         """Ausgabe der MD"""  
         return getattr(self,item)  
                   
     def index_html(self):  
         """standard page"""  
                   
         return self.REQUEST.RESPONSE.redirect(self.link)      def changeLabels(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/changeLabelsForm')
                   pt.content_type="text/html"
                   return pt()
   
     def generate_label(self):      def changeTitles(self):
         """Erzeugt_standard_Label aus Template"""                  """change form"""
         pt=getattr(self,"label_template_"+self.bib_type)                  pt=zptFile(self, 'zpt/changeTitleForm')
                   pt.content_type="text/html"
                   return pt()
   
       def changeWeights(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/changeWeightForm')
                   pt.content_type="text/html"
         return pt()          return pt()
   
 def manage_addECHO_resourceForm(self):      def changeMetaDataLinks(self):
         """Form for adding a ressource"""                  """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)                  pt=zptFile(self, 'zpt/changeMetaDataLinkForm')
                   pt.content_type="text/html"
         return pt()          return pt()
   
       def changeAccessRightsCollectionForm(self,preselect=None):
           """change access rights of all resources in this collection"""
   
           pt=zptFile(self, 'zpt/changeAccessRightsCollectionForm')
           pt.content_type="text/html"
           return pt(preselect=preselect)
   
 def manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):  
     """addaresource"""  
   
     newObj=ECHO_resource(id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords)      def changeAccessRightsCollection(self):
               """change"""
               ret=""
               argv=self.REQUEST.form
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
               for resource in resources:
                      
                       if argv.has_key(resource[1].getId()+'_xml'):
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()+'_xml']+"</br>"
                               resource[1].setAccessRightXML(argv[resource[1].getId()+'_xml'])
                               resource[1].accessRight=argv[resource[1].getId()+'_xml']
                       elif argv.has_key(resource[1].getId()+'_echo'):
                               ret+="only local:"+resource[1].getId()+"   "+argv[resource[1].getId()+'_echo']+"</br>"
                               resource[1].accessRight=argv[resource[1].getId()+'_echo']
                       else:
                               ret+="ERROR:" +resource[0]
               return ret
   
     self._setObject(id,newObj)      def changeMetaDataLinkInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
   
     if RESPONSE is not None:              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
         RESPONSE.redirect('manage_main')              for resource in resources:
     
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].metalink=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
 class ECHO_externalLink(Folder):      def changeMetaDataLinkInCollection(self):
     """Link zu einer externen Ressource"""              """change all lables of a collection"""
     security=ClassSecurityInfo()              ret=""
     meta_type='ECHO_externalLink'              argv=self.REQUEST.form
   
     def getTitle(self):              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
     """title"""              for resource in resources:
     return self.title.encode('utf-8')   
   
     def getLabel(self):                      try:
     """title"""                              ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
     return self.label.encode('utf-8')                               resource[1].metalink=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
     def content_html(self):      def changeWeightsInCollection(self):
         """template fuer content"""              """change all lables of a collection"""
         return content_html(self,'externalLink')              ret=""
               argv=self.REQUEST.form
           
     def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
               for resource in resources:
   
         self.id = id                      try:
         """Festlegen der ID"""                              ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].weight=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
         self.credits=toList(credits)      def changeTitlesInCollection(self):
         self.label = label              """change all lables of a collection"""
         self.link= link              ret=""
         self.title=title              argv=self.REQUEST.form
         self.weight=weight  
         self.description=description  
         self.contentType=contentType  
         self.responsible=responsible  
         coordsnew=[ string.split(x,",") for x in coords]  
         self.coords=coordsnew  
   
     def ECHO_externalLink_config(self):              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
         """Main configuration"""              for resource in resources:
   
         if not hasattr(self,'weight'):                      try:
             self.weight=""                              ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
         if not hasattr(self,'coords'):                              resource[1].title=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
                           
             self.coords=['']      def changeLabelsInCollection(self):
             #print "G",self.coords              """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 importCollection(self,path=None,viewerUrl=None,metaDataUrl=None,replacePathPermanent=None,replacePathExperimental=None,RESPONSE=None):
           """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)          if path is None:
                   pt=zptFile(self, 'zpt/importCollection.zpt')
         return pt()          return pt()
           
           files=os.listdir(path)
           ret=""
           for fileName in files:
   
     def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):              if fileName:
   
         """Änderung der Properties"""                  if (replacePathExperimental and replacePathExperimental!=''):
                       path=re.sub(replacePathExperimental,"/mpiwg/online/experimental",path)
                      
                   if (replacePathPermanent and replacePathPermanent!=''):
                       path=re.sub(replacePathPermanent,"/mpiwg/online/permanent",path)
                  
                   link=viewerUrl%(path+"/"+fileName+"/pageimg")
                   
                   metalink=metaDataUrl+"/"+path+"/"+fileName+"/index.meta"
     try:      try:
         coordsnew=[ string.split(x,",") for x in coords]  
                           #link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"
                           
                           newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'','book','','','','','','')
                           self._setObject(fileName,newObj)
                   
                           genObj=getattr(self,fileName)
                           #genObj.createIndexFile()
                           ret+="OK:"+fileName+"<br/>"
     except:      except:
         coordsnew=[]                          print "ERROR"
                           ret+="ERROR:"+fileName+"<br/>"
   
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)          return ret
   
         self.coords=coordsnew[0:]  
         self.link=link  
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
                           
     manage_options = Folder.manage_options+(      def changeViewerForm(self):
         {'label':'Main Config','action':'ECHO_externalLink_config'},              """change the viewer template set"""
         )              pt=zptFile(self, 'zpt/changeECHOViewer')
               return pt()
   
     def getCredits(self):      def getTextToolsField(self,name,default=''):
         """Ausgabe der credits"""              """Lese text tool field  der Collection not implemented yet!"""
         if self.credits:  
             return self.credits  
         else:  
             return []  
                   
     def index_html(self):              return default
         """standard page"""  
                   
         return self.REQUEST.RESPONSE.redirect(self.link)  
   
 def manage_addECHO_externalLinkForm(self):  
         """Form for external Links"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)  
         return pt()  
   
       def changeViewer(self,newViewer,REQUEST=None,RESPONSE=None):
           """changes all ressources to the newViewer"""
   
 def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):          resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
     """Add an external Link"""          if RESPONSE is not None:
                       RESPONSE.write("<html><body>")
   
           for resource in resources:
               
               done,msg=resource[1].changeViewer(newViewer)
               if done:
                   if RESPONSE is not None:
                       RESPONSE.write("<p>OK: %s"%resource[0])
               else:
                   if RESPONSE is not None:
                       RESPONSE.write("<p><a href='%s'>ERROR: %s (%s)</a>"%(resource[1].absolute_url()+'/ECHO_resource_config_main',resource[0],msg))
   
     newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)  
   
     self._setObject(id,newObj)  
   
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')                      RESPONSE.write("<p>Done</p></body></html>")
     
   
 class ECHO_link(ECHO_externalLink):  
     """external_link"""  
   
     meta_type="ECHO_link"      def copyTitleToInfoXMLFolder(self,RESPONSE=None):
               """copy title into the title field of info.xml
               author and date werden leer!!!
               """
           
   
     def content_html(self):              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
         """template fuer content"""  
         return content_html(self,'link')  
           
 def manage_addECHO_linkForm(self):  
         """Form for external Links"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)  
         return pt()  
   
               for resource in resources:
                       ret,txt=resource[1].copyTitleToInfoXML()
                       if (not ret) and RESPONSE:
                               RESPONSE.write("error: %s\n"%txt)
                       if ret and RESPONSE:
                               RESPONSE.write("ok: %s\n"%txt)
   
 def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):                      #logger("ECHO (copyTitleToInfoXMLFolder)",logging.INFO,txt)   
     """Add an external Link"""              if RESPONSE is not None:
                       RESPONSE.write("done!\n")
                       RESPONSE.close()
                       RESPONSE.redirect('manage_main')
   
     newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)      def copySearchFields(self,RESPONSE=None):
               """copys < metadatafields to the object"""
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
     self._setObject(id,newObj)              for resource in resources:
   
                       resource[1].copySearchFields()
   
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
   
 class ECHO_collection(Folder, Persistent, Implicit):  
     """ECHO Collection"""  
     security=ClassSecurityInfo()  
     meta_type='ECHO_collection'  
     viewClassificationList=viewClassificationListMaster  
     displayTypes=displayTypes  
   
     def getViewClassification(self):      def getPartnerCopyright(self,name,sonst="generic"):
         if hasattr(self,'viewClassification'):                  """gibt generisches copyright eines partners aus, sonst behalte jetzige einsteillung"""
             return self.viewClassification                  #print "hi",name,sonst
                   #print getattr(self.partners,name).copyrightType
                   try:
                           partner=getattr(self.partners,name)
                           return partner.copyrightType
                   except:
                           print "error"
                           return sonst
   
       def partnerSelector_HTML(self,selected=None):
            """give type selector"""
            if not selected:
                    retStr="<option selected>\n"
         else:          else:
             return ""                   retStr="<option>\n"
   
     def getTitle(self):           try: # erste version copyrightTypes exists
     """title"""                   for partner in self.getPartners():
     return self.title.encode('utf-8')                            partnerTitle = partner.title
                            partnerId = partner.__name__
                            if selected and (partnerId==selected):
                                    retStr+="""<option selected value="%s">%s\n"""%(partnerId,partnerTitle)
                            else:                
                                    retStr+="""<option value="%s">%s\n"""%(partnerId,partnerTitle)
            except:
                    """nothing"""
            return retStr
    
   #    def getViewClassification(self):
   #        if hasattr(self,'viewClassification'):
   #            return self.viewClassification
   #        else:
   #            return ""
   
     def getLabel(self):  
     """title"""  
     return self.label.encode('utf-8')   
   
     def createRessourcesFromXMLForm(self):      def createRessourcesFromXMLForm(self):
         """form"""          """form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)              pt=zptFile(self, 'zpt/createRessourcesFromXMLForm.zpt')
         return pt()          return pt()
   
     def createRessourcesFromXML(self,fileupload):      def createRessourcesFromXML(self,fileupload):
         """read an XML file for generating resources"""          """read an XML file for generating resources"""
         dom=xml.dom.minidom.parse(fileupload)          dom=xml.dom.minidom.parse(fileupload)
Line 920  class ECHO_collection(Folder, Persistent Line 1253  class ECHO_collection(Folder, Persistent
         for resource in dom.getElementsByTagName('resource'):          for resource in dom.getElementsByTagName('resource'):
             link=getText(resource.getElementsByTagName('link')[0].childNodes)              link=getText(resource.getElementsByTagName('link')[0].childNodes)
             label=getText(resource.getElementsByTagName('label')[0].childNodes)              label=getText(resource.getElementsByTagName('label')[0].childNodes)
                       pageimglink=getText(resource.getElementsByTagName('pageimglink')[0].childNodes)
             #splitted=link.split("?")[0].split("/")              #splitted=link.split("?")[0].split("/")
             #id=splitted[len(splitted)-1].encode('ascii')              #id=splitted[len(splitted)-1].encode('ascii')
             id=re.sub(" ","_",label).encode('ascii')              id=re.sub(" ","_",label).encode('ascii')
                           
             ret+="<p>"+label+"</p>"              ret+="<p>"+label+"</p>"
             manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","")                      manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","",pageimglink.encode('ascii'),link.encode('ascii'),"","")
         return ret          return ret
           
       security.declarePublic('getImageTag')
     def getImageTag(self):      def getImageTag(self):
         """GetTag"""          """GetTag"""
         try:          try:
Line 934  class ECHO_collection(Folder, Persistent Line 1270  class ECHO_collection(Folder, Persistent
         except:          except:
             return ""              return ""
   
   
       def addMovie(self,id,title,label,description,contentType,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits=None,coords=None,RESPONSE=None):
           """SSS"""
   
           #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):
                   try:
                           manage_addECHO_movie(self,id,title,label,description,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits=None,coords=None,RESPONSE=None)
                           return "done"
                   except:
                           return None
           else:
                   obj=getattr(self,id)
                   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"""
         try:          try:
             manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)              manage_addECHO_resource(self,id,title,label,description,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
             return "done"              return "done"
         except:          except:
               logging.error("ECHOcollection: (AddResource): %s %s"%sys.exc_info()[0:2])
             return None              return None
   
       def addResourceAndCreateLabelAndTitle(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
           """SSS"""
           ret = self.addResource(id,title,label,description,contentType,responsible,link,metalink,weight,credits,coords,RESPONSE)
           if ret is None:
               return None
           
           try:
               server2=getattr(self,id)
               server2.copyIndex_meta2echo_resource()
               server2.generate_label()
               server2.generate_title()
           except:
                 logging.error("An Error occured adding the resource A\n %s %s"%sys.exc_info()[0:2])
                 return None
           return "done"
     def getSecondaryLink(self):      def getSecondaryLink(self):
         """secondary link"""          """secondary link"""
         try:          try:
Line 956  class ECHO_collection(Folder, Persistent Line 1325  class ECHO_collection(Folder, Persistent
         except:          except:
             return ""              return ""
                   
     def getCollectionTreeXML(self):      def getCollectionTreeXML(self,pwstr=None):
         """Tree as XML"""          """Tree as XML"""
   
         def getCollection(object,depth=0):          def addPassWd(str,pwstr=None):
                   """adds a user/passwd to an url"""
                   if pwstr:
                           txt2=re.sub(r"(http://)(.*?)","\g<1>%s@\g<2>"%pwstr,str)
                   else:
                           txt2=re.sub(r"(http://)(.*?)","\g<1>www:3333@\g<2>",str)
                   return txt2
   
           def getCollection(object,depth=0,pwstr=None):
             depth+=1              depth+=1
             collections=""              collections=""
             for entry in object.__dict__.keys():              for entry in object.__dict__.keys():
                 element=getattr(object,entry)                  element=getattr(object,entry)
                 try:                  try:
                     if element.meta_type in ["ECHO_collection","ECHO_group"]:                      if element.meta_type in ["ECHO_collection","ECHO_group"]:
                         collections+="<element name=\""+quote(element.title)+"\" url=\""+element.absolute_url()+"\">"                          collections+="<element name=\""+urllib.quote(element.title)+"\" url=\""+addPassWd(element.absolute_url(),pwstr=pwstr)+"\">"
                         collections+=getCollection(element,depth)+"</element>\n"                          collections+=getCollection(element,depth)+"</element>\n"
                 except:                  except:
                     """nothing"""                      """nothing"""
             return collections              return collections
                   
     ret="""<?xml version="1.0" encoding="utf-8" ?>"""      ret="""<?xml version="1.0" encoding="utf-8" ?>"""
         return ret+"<collection>"+getCollection(self)+"</collection>"          return ret+"<collection>"+getCollection(self,pwstr=pwstr)+"</collection>"
           
     def createJavaScript(self):      def createAllJSAreas(self,mapColTypes=None):
         """CreateJava"""          """create area calls for JavaScript"""
         ret=javaScriptMain          areas = self.getAllMapAreas(mapColTypes=mapColTypes)
           return self.createJSAreas(areas)
         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):  
         """new version of createJavaScript"""  
         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):  
         """generate divs"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)  
         return pt()  
           
     def createMapLink(self, ob, text=None):  
     """generate map link"""  
     id = ob[1]  
     link = ob[1]  
     if text == None:  
         text = ob[2]  
     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  
       
     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]  
         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:  
         tag += '<span id="i.%s" style="position:absolute; top:-100px; left:-100px; border-style:none"'%(id)  
         if ctype == "text-popup":  
         desc = ob[3].description  
         tag += ' title="%s"'%desc  
         tag += ' />'  
     tag += '</a>'  
     return tag  
   
       emptyPartner=ECHO_partner("", "","", "", "", "", "", "", "")
           
     security.declarePublic('getCreditObject')      security.declarePublic('getCreditObject')
     def getCreditObject(self,name):      def getCreditObject(self,name):
Line 1043  class ECHO_collection(Folder, Persistent Line 1366  class ECHO_collection(Folder, Persistent
         try:          try:
             return getattr(self.partners,name)              return getattr(self.partners,name)
         except:          except:
             return ""              
               return self.emptyPartner
                   
   
     security.declarePublic('ECHO_generateNavBar')      security.declarePublic('ECHO_generateNavBar')
     def ECHO_generateNavBar(self):      def ECHO_generateNavBar(self):
Line 1064  class ECHO_collection(Folder, Persistent Line 1389  class ECHO_collection(Folder, Persistent
                     ret.append((label,link))                      ret.append((label,link))
         return ret          return ret
           
     security.declarePublic('ECHO_rerenderLinksMD')  
   
     def ECHO_rerenderLinksMD(self,obj=None):      def ECHO_rerenderLinksMDWarning(self):
         """Rerender all Links"""                  """change form"""
         if not obj:                  pt=zptFile(self, 'zpt/rerenderLinksWarning')
             obj = self                  pt.content_type="text/html"
                               return pt()
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])  
   
         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])  
   
                   
                   
         return "Rerenderd all links to resources in: "+self.title  
   
     security.declarePublic('ECHO_newViewerLink')  
           
   
     def getCoords(self):  
         try:  
                           
             x=  [string.join(x,",") for x in self.coords]        security.declarePublic('ECHO_rerenderLinksMD')
             return x      def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
           """Rerender all Links"""
         except:          return ECHO_rerenderLinksMD(self,obj,types)
   
             return []  
                   
     def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):      def __init__(self,id,title,label,description="",contentType="",responsible="",credits="",weight="",sortfield="",coords=[],secondaryLinkTitle="",secondaryLink="",imageTag="",bgcolour="",isVisible=True):
         #print "CO",coords  
   
         self.id = id          self.id = id
         """Festlegen der ID"""          """Festlegen der ID"""
Line 1116  class ECHO_collection(Folder, Persistent Line 1422  class ECHO_collection(Folder, Persistent
         self.secondaryLinkTitle=secondaryLinkTitle          self.secondaryLinkTitle=secondaryLinkTitle
         self.secondaryLink=secondaryLink          self.secondaryLink=secondaryLink
     self.bgcolour=bgcolour      self.bgcolour=bgcolour
           self.isVisible=isVisible
                   
   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+ Cacheable.manage_options+(
         {'label':'Main Config','action':'ECHO_collection_config'},          {'label':'Main Config','action':'ECHO_collection_config'},
         {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},          {'label':'Change Labels','action':'changeLabels'},
         {'label':'Graphics','action':'ECHO_graphicEntry'},          {'label':'Change Titles','action':'changeTitles'},
           {'label':'Localize','action':'localizeObjects'},
           {'label':'Change Weights','action':'changeWeights'},
           {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},
           {'label':'Export/Import Objects','action':'exportImportObjects_html'},
           {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
     {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},      {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
           {'label':'Change Image Viewer','action':'changeViewerForm'},
           {'label':'ImportCollection','action':'importCollection'},
           {'label':'Change access rights',  'action':'changeAccessRightsCollectionForm'},
         )          )
   
     def getOverview(self):  
         """overview graphics"""  
           
         return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]  
       
       
     def ECHO_graphicEntry(self):  
         """DO nothing"""  
         overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])  
           
       
         if overview:  
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)  
             return pt()  
         else:  
             return "NO OVERVIEW GRAPHICS"  
   
     def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):  
         """Enter coords"""  
         coords=self.coords  
         temco=coordstr.split(",")  
         temco.append(angle)  
         coords.append(temco)  
         self.coords=coords[0:]  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('ECHO_graphicEntry')  
   
           
     security.declarePublic('ECHO_collection_config')      security.declarePublic('ECHO_collection_config')
     def ECHO_collection_config(self):      def ECHO_collection_config(self):
Line 1165  class ECHO_collection(Folder, Persistent Line 1451  class ECHO_collection(Folder, Persistent
         if not hasattr(self,'sortfield'):          if not hasattr(self,'sortfield'):
             self.sortfield="weight"              self.sortfield="weight"
       
         if not hasattr(self,'coords'):          pt=zptFile(self, 'zpt/ChangeECHO_Collection.zpt')
             self.coords=[]  
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_collection.zpt').__of__(self)  
         return pt()          return pt()
   
   
     security.declarePublic('changeECHO_collection')  
   
   
     def getBgcolour(self):      def getBgcolour(self):
         """colour"""          """colour"""
         if hasattr(self,'bgcolour') and not (self.bgcolour==""):          if hasattr(self,'bgcolour') and not (self.bgcolour==""):
Line 1182  class ECHO_collection(Folder, Persistent Line 1462  class ECHO_collection(Folder, Persistent
         else:          else:
             return "#dddddd"              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):                  
       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,prefix="",suffix="",isVisible=True):
         """Aenderung der Properties"""          """Aenderung der Properties"""
   
         self.secondaryLink=secondaryLink          self.secondaryLink=secondaryLink
         self.secondaryLinkTitle=secondaryLinkTitle          self.secondaryLinkTitle=secondaryLinkTitle
         self.imageTag=imageTag          self.imageTag=imageTag
     self.bgcolour=bgcolour      self.bgcolour=bgcolour
         self.viewClassification=viewClassification          self.location=location
           self.isAlwaysClickable=isAlwaysClickable
           self.prefix=prefix[0:]
           self.suffix=suffix[0:]
           self.setIsVisible(isVisible)
           
         if coords:          setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
             coordsnew=[ string.split(x,",") for x in coords]  
             self.coords=coordsnew[0:]  
         else:  
             coordsnew=None  
             self.coords=None  
               
         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
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
     security.declarePublic('index_html')      def setAlwaysClickable(self,flag="yes"):
               """set clickable"""
               if flag=="yes":
                       self.isAlwaysClickable="yes"
               else:
                       self.isAlwaysClickable=None
   
               return flag
   
     def showOverview(self):      def showOverview(self):
         """overview"""          """overview"""
         if 'ECHO_overview.html' in self.__dict__.keys():          # use ECHO_overview.html template in this instance
             return getattr(self,'ECHO_overview.html')()          if 'ECHO_overview.html' in self:
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)              return self['ECHO_overview.html']()
           
           # use ECHO_overview_main template in path
           if hasattr(self, 'ECHO_overview_main'):
               return getattr(self, 'ECHO_overview_main')()
           
           # use template from Product
           pt=zptFile(self, 'zpt/ECHO_content_overview.zpt')
         return pt()          return pt()
   
           
       security.declareProtected('View','index_html')
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
           if self.ZCacheable_isCachingEnabled():
               result = self.ZCacheable_get()
               if result is not None:
                   # Got a cached value.
                   return result
               
           # old Zope 2.9 method
           #if 'index.html' in self.__dict__.keys():
           #    ret=getattr(self,'index.html')()
   
           # use Zope 2.12 IContainer for child access
           if 'index.html' in self:
               # use index.html template if it exists
               ret = self['index.html']()
               
           elif 'overview' in self:
               # use red-rectangle template when there's an 'overview'
               ret=self.showOverview()
                   
         if 'index.html' in self.__dict__.keys():          # use getattr for acquisition
             return getattr(self,'index.html')()  
           
         elif 'overview' in self.__dict__.keys():  
             return self.showOverview()  
         elif hasattr(self,'collection_index_template'):          elif hasattr(self,'collection_index_template'):
             return self.collection_index_template()                  # use 'collection_index_template' in acquisition path
               ret=self.collection_index_template()
               
         elif hasattr(self,'main_index_template'):          elif hasattr(self,'main_index_template'):
             return self.main_index_template()                  # use 'main_index_template' in acquisition path
               ret=self.main_index_template.__of__(self)(self.main_template)
                   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)          else:
               # use template from Product
               pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()              ret=pt.render()
   
     def content_html(self):          self.ZCacheable_set(ret)
           return ret
   
       security.declarePublic('content_html')
       def content_html(self,**argv):
         """template fuer content"""          """template fuer content"""
         return content_html(self,'collection')          #print "NN",argv
           ret = ECHO_basis.content_html(self,'collection')
           
           if type(ret) is StringType:
                  return ret.decode('utf-8')
           else:
                  return ret
           
           
     def getCredits(self):      def getCredits(self):
         """Ausgabe der credits"""          """Ausgabe der credits"""
Line 1250  class ECHO_collection(Folder, Persistent Line 1569  class ECHO_collection(Folder, Persistent
   
     def area_img(self):      def area_img(self):
         """area image"""          """area image"""
           bt = browserType(self)
           if bt['isIE'] or bt['isN4']:
         return sendFile(self, 'images/red.gif', 'image/gif')          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):      def hl_lib_js(self):
         """javascript"""          """javascript"""
         sendFile(self, 'js/hl_lib.js', 'text/plain')          return sendFile(self, 'js/hl_lib.js', 'text/plain')
         return   
   
     def js_lib_js(self):      def js_lib_js(self):
           """javascript -- old name"""
           return sendFile(self, 'js/baselib.js', 'text/plain')
   
       def baselib_js(self):
         """javascript"""          """javascript"""
         sendFile(self, 'js/js_lib.js', 'text/plain')          return sendFile(self, 'js/baselib.js', 'text/plain')
         return   
   
     def getGraphicCoords(self):      def hl_add_js(self):
         """Give list of coordinates"""          """javascript"""
         subColTypes=['ECHO_collection','ECHO_resource']          return sendFile(self, 'js/hl_add.js', 'text/plain')
         ids=[]  
         for entrySearch in self.ZopeFind(self,obj_metatypes=subColTypes):  
             object=entrySearch[1]  
             if hasattr(object,'coords'):  
                 for coordtemp in object.coords:  
                     if len(coordtemp)>3:  
                         coord=coordtemp[0:4]  
                         label=""  
             vc=""  
                         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:  
                 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  
           
       def getAllMapAreas(self,mapColTypes=None):
           """Give list of coordinates"""
           if mapColTypes is None:
               mapColTypes=['ECHO_collection','ECHO_resource','ECHO_link','ECHO_externalLink']
   
           areas=[]
           for entry in self.getSubCols(subColTypes=mapColTypes):
               object=entry
               areas.extend(object.getMapAreas())
           return areas
       
   
       def deleteMapAreas(self):
           """deletes all map areas from this object"""
           for obs in self.ZopeFind(self, obj_metatypes=['MapArea'], search_sub=1):
               ob = obs[1]
               id = ob.id
               parent = ob.aq_parent
               print "deleting: ", ob.id
               parent._delObject(id)
           return "Done"
   
   
     getSubCols = ECHO_helpers.getSubCols      getSubCols = ECHO_helpers.getSubCols
             
       def getSubcolsXMLRpc(self,searchSimple):
           """simplesearch results suitable for xml rpc, gives back array objid,url"""
           
           return [x.absolute_url() for x in self.getSubCols(searchSimple=searchSimple)]
       
       
       def exportPageTemplateContents(self,REQUEST=None):
           """hole nur den inhalt aus page templates"""
           
           import json
           import base64
           from BeautifulSoup import BeautifulSoup
           
           
           ret={}
           #contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
           contents=self.ZopeFind(self,obj_metatypes=['Page Template'],search_sub=1)
           #contents=self.ZopeFind(self)
           
           
           for content in contents:
               colId = content[1].absolute_url().replace(self.absolute_url(),'')
            
               html=content[1].render()
               parsed = BeautifulSoup(html)
                   
                   
               cnt = parsed.findAll(attrs={'class':'stage'})
               if len(cnt) > 0: #sollte nur einen gebenbt:
                   ret[colId]=base64.b64encode(cnt[0].prettify())
                   
           if REQUEST:
                   REQUEST.response.setHeader("Content-type", "text/json; charset=utf-8")
          
                                   
           return json.dumps(ret)
           
   Globals.InitializeClass(ECHO_collection)
           
 def manage_addECHO_collectionForm(self):  def manage_addECHO_collectionForm(self):
         """Add collection form"""          """Add collection form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)          pt=zptFile(self, 'zpt/AddECHO_collectionForm.zpt')
         return pt()          return pt()
   
   
 def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):  def manage_addECHO_collection(self,id,title,label,description="",contentType="",responsible="",weight=0,sortfield="weight",coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",isVisible=True):
     """add a echo collection"""      """add a echo collection"""
           
   
     newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")      newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="",isVisible=isVisible)
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
   
Line 1317  def manage_addECHO_collection(self,id,ti Line 1678  def manage_addECHO_collection(self,id,ti
   
 class ECHO_group(ECHO_collection):  class ECHO_group(ECHO_collection):
     """ECHO Gruppe"""      """ECHO Gruppe"""
           security=ClassSecurityInfo()
     meta_type="ECHO_group"      meta_type="ECHO_group"
   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Main Config','action':'ECHO_group_config'},          {'label':'Main Config','action':'ECHO_group_config'},
         {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},                  {'label':'Rerender Links','action':'ECHO_rerenderLinksMDWarning'},
         {'label':'Graphics','action':'ECHO_graphicEntry'},                  {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
         )          )
   
           security.declareProtected('View','index_html')
   
   
           def getRDF(self,urn=None):
               """rdf of the collection"""
               contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
   
               ret=getRDFDescription(self,self.absolute_url(),urn=urn)
   
               
               if not urn:
                       urn=self.absolute_url()
               li="""<rdf:li rdf:resource="%s" />\n"""
               
               
               for content in contents:
                       ret+=self.unicodify(content[1].getRDF())+"\n"
                       
               ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
               for content in contents:
                       nurn=content[1].absolute_url()
                       ret+=li%nurn
               return ret+"</rdf:Seq>"
               
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
         displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)          displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
Line 1343  class ECHO_group(ECHO_collection): Line 1729  class ECHO_group(ECHO_collection):
         elif hasattr(self,'main_index_template'):          elif hasattr(self,'main_index_template'):
             return self.main_index_template()                  return self.main_index_template()    
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)                  pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
Line 1359  class ECHO_group(ECHO_collection): Line 1745  class ECHO_group(ECHO_collection):
         if not hasattr(self,'coords'):          if not hasattr(self,'coords'):
             self.coords=[]              self.coords=[]
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)                  pt=zptFile(self, 'zpt/ChangeECHO_group.zpt')
         return pt()          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=""):      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"""                  """Aenderung der Properties"""
   
         self.secondaryLink=secondaryLink          self.secondaryLink=secondaryLink
         self.secondaryLinkTitle=secondaryLinkTitle          self.secondaryLinkTitle=secondaryLinkTitle
Line 1371  class ECHO_group(ECHO_collection): Line 1757  class ECHO_group(ECHO_collection):
         self.bgcolour=bgcolour          self.bgcolour=bgcolour
                 self.logo=logo                  self.logo=logo
                                   
         if coords:                  setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
             coordsnew=[ string.split(x,",") for x in coords]  
             self.coords=coordsnew[0:]  
         else:  
             coordsnew=None  
             self.coords=None  
   
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)  
   
   
   
Line 1394  class ECHO_group(ECHO_collection): Line 1773  class ECHO_group(ECHO_collection):
                 except:                  except:
                     return "ECHO_groups"                      return "ECHO_groups"
   
           security.declarePublic('content_html')
     def content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content"""
         return content_html(self,'group')                  return ECHO_basis.content_html(self,'group')
           
   
   
 def manage_addECHO_groupForm(self):  def manage_addECHO_groupForm(self):
         """Add group form"""          """Add group form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)          pt=zptFile(self, 'zpt/AddECHO_groupForm.zpt')
         return pt()          return pt()
   
   
Line 1418  def manage_addECHO_group(self,id,title,l Line 1798  def manage_addECHO_group(self,id,title,l
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   Globals.InitializeClass(ECHO_group)
   
           
 class ECHO_root(Folder,Persistent,Implicit):  class ECHO_userFolder(UserFolder):
     """ECHO Root Folder"""          """User folder for Intranet"""
     meta_type="ECHO_root"          _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 getImageTag(self):          def domainSpecMatch(self,spec, request):
         """needed by main_template"""              host=''
         return ""              addr=''
     secondaryLink="" #needed by main_template  
     secondaryLinkTitle="" #needed by main_template  
           
     def getBgcolour(self):              # Fast exit for the match-all case
     """hack"""              if len(spec) == 1 and spec[0] == '*':
     return "#dddddd"                  return 1
   
     def contentTypeSelector_HTML(self,selected=None):              if request.has_key('REMOTE_HOST'):
         """give type selector"""                  host=request['REMOTE_HOST']
         if not selected:  
             retStr="<option selected>\n"              if request.has_key('REMOTE_ADDR'):
         else:                  addr=request['REMOTE_ADDR']
             retStr="<option>\n"  
               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
   
   # ROC: problem with 2.12
   #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)
   
   
   
   def createNode(self,descrs,node):
           name=descrs[node]['name']
           type=descrs[node]['type']
           urn=node
           #print "    will create",node.encode('utf-8')
           id=re.sub('[^a-zA-Z0-9]','',name).encode('ascii','ignore')
           #print "id",id
           #print type
           #self.REQUEST.RESPONSE.write("<p>%s<p>\n"%id)
           if type=="CDLI_group":
                           
         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:
             for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):                          manage_addECHO_collection(self,id,name,name,"","","","","")
                 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:          except:
             """nothing"""                          self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
                                   
     return retStr                  self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
   
     def renderingTypeSelector_HTML(self,selected=None):                  return type,getattr(self,id),urn
          """give type selector"""  
      if not selected:  
          retStr="<option selected>\n"  
      else:  
          retStr="<option>\n"  
                     
      try: # erste version renderingTypes exists          if type=="CDLI_item":
          for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):                  try:
              if selected and (renderingType[0]==selected):                          manage_addECHO_resource(self,id,name,name,"","",urn,"","")
                  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"""                          self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
      return retStr                  self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
   
     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          return "XX"
          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,selected=None):  
          """give type selector"""  
      if not selected:  
          retStr="<option selected>\n"  
      else:  
          retStr="<option>\n"  
                     
      try: # erste version copyrightTypes exists  class ECHO_copyrightType(Folder,ECHO_basis):
          for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):          """copyright typ"""
              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:  
          """nothing"""  
      return retStr  
   
           meta_type="ECHO_copyrightType"
                           
     def patchContentType(self,obj=None):          def __init__(self,id,title,label,url):
         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""                  """init"""
                   self.id=id
                   self.title=title
                   self.label=label
                   self.url=url
           
           manage_options = Folder.manage_options+(
           {'label':'Main Config','action':'ECHO_copyrightType_config_mainForm'},
           )
   
         if not obj:          def ECHO_copyrightType_config_mainForm(self):
             obj = self                  """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_copyrightType')
                   pt.content_type="text/html"
                   return pt()
                           
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])          def ECHO_copyrightType_config_main(self,title,label,url,RESPONSE=None):
                   """change"""
                   self.title=title
                   self.label=label
                   self.url=url
   
         for entry in entries:                  if RESPONSE is not None:
                 setattr(entry[1],'contentType',entry[1].content_type)                          RESPONSE.redirect('manage_main')
                 #entry[1].contentType == entry[1].content_type  
   
                 if entry[1].meta_type == 'ECHO_collection':  def manage_addECHO_copyrightTypeForm(self):
                     entry[1].patchContentType(entry[1])              """Form for adding a ressource"""
           pt=zptFile(self, 'zpt/AddECHO_copyrightTypeForm.zpt')
           return pt()
   
                                   
         return "changed all contenttypes in: "+self.title  def manage_addECHO_copyrightType(self,id,title,label,url,RESPONSE=None):
       """addaresource"""
   
       newObj=ECHO_copyrightType(id,title,label,url)
   
     def patchViewClassification(self,obj=None):      self._setObject(id,newObj)
         """setze viewClassification heuristisch"""  
   
     def checkIfArrow(obj):      if RESPONSE is not None:
         if hasattr(obj,'coords'):          RESPONSE.redirect('manage_main')
             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]):  class ECHO_linkList(ZopePageTemplate,ECHO_basis):
             setattr(entry[1],'viewClassification','view point')      """LinkList Objekt"""
         else:      meta_type="ECHO_linkList"
             setattr(entry[1],'viewClassification','area')  
       _default_content_fn = os.path.join(package_home(globals()), 'html/ECHO_pageTemplateDefault.html')
   
                 #entry[1].contentType == entry[1].content_type      manage_options = ZopePageTemplate.manage_options+(
           {'label':'Main Config','action':'changeECHO_linkListWeightForm'},
           )
   
                 if entry[1].meta_type in ['ECHO_collection','ECHO_group']:      def content_html(self):
                     entry[1].patchViewClassification(entry[1])              """content_html"""
           return ECHO_basis.content_html(self,'pageTemplate')
   
       def changeECHO_linkListWeightForm(self):
           """change"""
           pt=zptFile(self, 'zpt/ChangeECHO_linkListTemplate.zpt')
           return pt()
                                   
         return "changed all contenttypes in: "+self.title      def changeECHO_linkListWeight(self,contentType,label,RESPONSE=None):
           """change"""
           self.contentType=contentType
           self.label=label
   
     def ECHO_newViewerLink(self,obj=None):          if RESPONSE is not None:
         """change links (:86 faellt weg)"""              RESPONSE.redirect('manage_main')
   
         if not obj:      def getLabel(self):
             obj = self          if hasattr(self,'label'):
               return self.label.encode('utf-8')
           else:
               return 0
                           
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])      def getcontentType(self):
           """get contentType"""
           if hasattr(self,'contentType'):
               return normalizeCt(self.contentType)
           else:
               return 0
   
         for entry in entries:      def __init__(self, id, label, title=None, text=None, contentType=None):
            self.id = str(id)
            self.title=title
            self.label=label
            self.ZBindings_edit(self._default_bindings)
            if text is None:
                text = ''
            if content_type is None:
                content_type = self.content_type
            self.pt_edit(text, contentType)
                                   
                 if entry[1].meta_type == 'ECHO_resource':  
                                           
                     entry[1].link=re.sub('\:86','',entry[1].link)  
   
   
   def manage_addECHO_linkListForm(self):
       """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_linkListTemplate.zpt')
       return pt()
   
   
   def manage_addECHO_linkList(self, id, label,contentType=0,title=None, text=None,
                              REQUEST=None, submit=None):
       """Add a LinkList with optional file content."""
       
       id = str(id)
       if REQUEST is None:
           self._setObject(id, ECHO_linkList(id, label, text))
           ob = getattr(self, id)
           setattr(ob,'contentType',contentType)
           if title:
               ob.pt_setTitle(title)
           return ob
                 else:                  else:
           file = REQUEST.form.get('file')
           headers = getattr(file, 'headers', None) 
           if (headers is None) or (not file.filename):
               zpt = ECHO_linkList(id, file)
           else:
               zpt = ECHO_linkList(id, label,'', file, headers.get('contentType'))
                                           
                     entry[1].ECHO_newViewerLink(entry[1])          self._setObject(id, zpt)
           ob = getattr(self, id)
           if title:
               ob.pt_setTitle(title)
                                   
         return "Rerenderd all links to resources in: "+self.title          try:
               u = self.DestinationURL()
           except AttributeError:
               u = REQUEST['URL1']
   
     def __init__(self,id,title):          if submit == " Add and Edit ":
               u = "%s/%s" % (u, urllib.quote(id))
           REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
       
   
   class ECHO_support(Folder,ECHO_basis):
           """gefoerdert durch"""
           meta_type="ECHO_support"
           
           
           
           def __init__(self,id,institutions=None):
         """init"""          """init"""
         self.id = id          self.id = id
         self.title=title                  self.title=''
                   self.institutions=toList(institutions)
   
     def deleteSpace(self,str):          def getSupporter(self):
         """delete space at the end of a line"""                  """return institutions"""
         if str[len(str)-1]==" ":                  if self.institutions:
             return str[0:len(str)-1]                          return self.institutions
         else:          else:
             return str                          return []
                   
           manage_options = Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_support_configForm'},
                   )
           
           def ECHO_support_configForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_support')
                   pt.content_type="text/html"
                   return pt()
   
     # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt          def ECHO_support_config(self,institutions=None,RESPONSE=None):
                   """change"""
                   self.institutions=toList(institutions)
   
     def formatAscii(self,str,url=None):                  if RESPONSE is not None:
         """ersetze ascii umbrueche durch <br>"""                          RESPONSE.redirect('manage_main')
         #url=None  
         if url:  
                           
             retStr=""  
             words=str.split("\n")  
                           
             for word in words:  def manage_addECHO_supportForm(self):
                 strUrl=url%word      """Form for adding"""
                 #print "str",strUrl      pt=zptFile(self, 'zpt/AddECHO_support.zpt')
                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)      return pt()
             str=retStr  
         if str:  
             return re.sub(r"[\n]","<br/>",str)  
         else:  
             return ""  
                   
     def link2html(self,str):  def manage_addECHO_support(self, id,institutions=None,RESPONSE=None):
         """link2html fuer VLP muss hier noch raus"""          """add the copyright"""
         if str:  
             #print str  
             str=re.sub("\&","&amp;",str)  
             dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")  
             links=dom.getElementsByTagName("link")  
               
             #print "link",links  
             for link in links:  
                 link.tagName="a"  
                 ref=link.getAttribute("ref")  
                 if self.checkRef(ref):  
                     link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)  
   
             return dom.toxml('utf-8')          meta_type="ECHO_support"
         return ""  
   
   
     def checkRef(self,ref):          self._setObject(id, ECHO_support(id,institutions))
         dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}  
         res=None  
         for db in dbs.keys():  
             #print ref,"select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])  
   
             res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))          if RESPONSE is not None:
         return res                  RESPONSE.redirect('manage_main')
                                                                           
     #Ende Methode fuer vlp  # ECHO - owner of original
   class ECHO_ownerOriginal(Folder,ECHO_basis):
           """besitzer des originals"""
           meta_type="ECHO_ownerOriginal"
           security=ClassSecurityInfo()
   
     def PgQuoteString(self,string):  
         """Quote string"""  
         #print "PG",string  
         return libpq.PgQuoteString(string)  
                   
     def getPartners(self):          def __init__(self,id,institutions=None):
         """Get list of Partners. Presently only from a subfolder partners"""                  """init"""
                   self.id=id
                   self.title=''
                   self.institutions=toList(institutions)
                                           
         return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]          security.declarePublic('getOwner')
           def getOwner(self):
                   """return institutions"""
                   if self.institutions:
                           return self.institutions
                   else:
                           return []
                                   
           manage_options = Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_ownerOriginal_configForm'},
                   )
                                   
           def ECHO_ownerOriginal_configForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_ownerOriginal')
                   pt.content_type="text/html"
                   return pt()
                                         
           def ECHO_ownerOriginal_config(self,institutions=None,RESPONSE=None):
                   """change"""
                   self.institutions=toList(institutions)
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
           
     def getPartnersXML(self):  
         """partner liste als xml"""   
         partners=self.getPartners()  
         ret="""<?xml version="1.0" encoding="utf-8" ?>  
     <partners>"""  
                   
     for partner in partners:  def manage_addECHO_ownerOriginalForm(self):
             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),unicode(partner.title,'utf-8','replace'))      """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_ownerOriginal.zpt')
       return pt()
   
         return ret+"\n</partners>"  def manage_addECHO_ownerOriginal(self, id,institutions=None,RESPONSE=None):
           """add the copyright"""
           
     def getCollectionTree(self):          meta_type="ECHO_ownerOriginal"
         """get the collection tree (list of triples (parent,child, depth)"""  
   
         def getCollection(object,depth=0):  
             depth+=1  
             collections=[]  
             for entry in object.__dict__.keys():  
                 element=getattr(object,entry)  
                 try:  
                     if element.meta_type=="ECHO_collection":  
                         collections.append((object,element,depth))  
                         collections+=getCollection(element,depth)  
                 except:  
                     """nothing"""  
             return collections  
                   
           self._setObject(id, ECHO_ownerOriginal(id,institutions))
   
         return getCollection(self)          if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
           
     def getCollectionTreeIds(self):  # --------------------------------------------------------------------------------             
         """Show the IDs of the Tree"""  
         ret=[]  
         for collection in self.getCollectionTree():  
             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))  
         return ret  
   
   # ECHO - digitized copy by
   class ECHO_digiCopyBy(Folder,ECHO_basis):
           """besitzer des originals"""
           meta_type="ECHO_digiCopyBy"
           security=ClassSecurityInfo()
                   
                   
 def manage_addECHO_root(self,id,title,RESPONSE=None):          def __init__(self,id,institutions=None):
     """Add an ECHO_root"""                  """init"""
     self._setObject(id,ECHO_root(id,title))                  self.id=id
                   self.title=''
                   self.institutions=toList(institutions)
   
           security.declarePublic('getDigiCopyBy')
           def getDigiCopyBy(self):
                   """return institutions"""
                   if self.institutions:
                           return self.institutions
                   else:
                           return []
                   
           manage_options = Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_digiCopyBy_configForm'},
                   )
   
           def ECHO_digiCopyBy_configForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_digiCopyBy')
                   pt.content_type="text/html"
                   return pt()
   
           def ECHO_digiCopyBy_config(self,institutions=None,RESPONSE=None):
                   """change"""
                   self.institutions=toList(institutions)
           
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
 def manage_addECHO_rootForm(self):                  
         """Nothing yet"""  def manage_addECHO_digiCopyByForm(self):
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)      """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_digiCopyBy.zpt')
         return pt()          return pt()
     
 class ECHO_partner(Image,Persistent):  def manage_addECHO_digiCopyBy(self, id,institutions=None,RESPONSE=None):
     """ECHO Partner"""          """add the copyright"""
   
           meta_type="ECHO_digiCopyBy"
   
     meta_type="ECHO_partner"  
   
     def __init__(self, id, title,url, file, content_type='', precondition=''):          self._setObject(id, ECHO_digiCopyBy(id,institutions))
   
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
                   
   # --------------------------------------------------------------------------------  
   
   class ECHO_institution(Image,Persistent,ECHO_basis):
       """ECHO Institution"""
   
       meta_type="ECHO_institution"
   
       def __init__(self, id, title,url, file, person, email, country, content_type='', precondition=''):
         self.__name__=id          self.__name__=id
         self.title=title          self.title=title
         self.url=url          self.url=url
           self.person=person
           self.email=email
           self.country=country
         self.precondition=precondition          self.precondition=precondition
   
         data, size = self._read_data(file)          data, size = self._read_data(file)
         content_type=self._get_content_type(file, data, id, content_type)          content_type=self._get_content_type(file, data, id, content_type)
         self.update_data(data, content_type, size)          self.update_data(data, content_type, size)
   
     manage_options = Image.manage_options+(      manage_options = Image.manage_options+(
         {'label':'Partner Information','action':'ECHO_partner_config'},          {'label':'Institution Information','action':'ECHO_institution_config'},
         )          )
   
     def changeECHO_partner(self,url,RESPONSE=None):      
       def changeECHO_institution(self,url,person, email, country,RESPONSE=None):
         """Change main information"""          """Change main information"""
         self.url=url          self.url=url
           self.person=person
           self.email=email
           self.country=country
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
                           
   
     def ECHO_partner_config(self):      def ECHO_institution_config(self):
         """Main configuration"""          """Main configuration"""
         if not hasattr(self,'url'):          if not hasattr(self,'url'):
             self.url=""              self.url=""
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_partner.zpt').__of__(self)          pt=zptFile(self, 'zpt/ChangeECHO_institution.zpt')
         return pt()          return pt()
   
                   
 manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),  manage_addECHO_institutionForm=DTMLFile('dtml/ECHO_institutionAdd',globals(),
                              Kind='ECHO_partner',kind='ECHO_partner')                               Kind='ECHO_institution',kind='ECHO_institution')
   
   
   
 def manage_addECHO_partner(self, id, file,url, title='', precondition='', content_type='',  def manage_addECHO_institution(self, id, url, person, email, country, file=None, title='', precondition='', content_type='',
                     REQUEST=None):                      REQUEST=None):
     """      """
     Add a new ECHO_partner object.      Add a new ECHO_institution object.
   
     Creates a new ECHO_partner object 'id' with the contents of 'file'.      Creates a new ECHO_institution object 'id' with the contents of 'file'.
     Based on Image.manage_addImage      Based on Image.manage_addImage
     """      """
   
Line 1773  def manage_addECHO_partner(self, id, fil Line 2328  def manage_addECHO_partner(self, id, fil
     self=self.this()      self=self.this()
   
     # First, we create the image without data:      # First, we create the image without data:
     self._setObject(id, ECHO_partner(id,title,url,'',content_type, precondition))      self._setObject(id, ECHO_institution(id,title,url,'', person, email, country, content_type, precondition))
   
     # Now we "upload" the data.  By doing this in two steps, we      # Now we "upload" the data.  By doing this in two steps, we
     # can use a database trick to make the upload more efficient.      # can use a database trick to make the upload more efficient.
Line 1788  def manage_addECHO_partner(self, id, fil Line 2343  def manage_addECHO_partner(self, id, fil
         REQUEST.RESPONSE.redirect('%s/manage_main' % url)          REQUEST.RESPONSE.redirect('%s/manage_main' % url)
     return id      return id
   
   def repairCoords(self):
           """updates map coordinates to new MapArea objects"""
           msg = ""
           for cols in self.ZopeFind(self, obj_metatypes=['ECHO_collection','ECHO_resource'], search_sub=1):
               col = cols[1]
               if not hasattr(col, 'coords'):
                   continue
               print "fixing: ", col.id
               msg += "fixing: "+col.id+"\n"
               coords = col.coords
               if len(coords) > 0:
                   # delete old MapAreas
                   for areas in self.ZopeFind(col, obj_metatypes=['MapArea']):
                       #area = areas[1]
                       id = areas[0]
                       print "  deleting: ", id
                       msg += "  deleting: "+id+"\n"
                       col._delObject(id)
                   # add new MapAreas
                   areacnt = 0
                   for coord in coords:
                       if len(coord) < 4:
                           continue
                       type = col.viewClassification
                       if type == 'view point':
                           type = 'arrow'
                       if type is None:
                           if len(coord) > 4:
                               type = 'arrow'
                           else:
                               type = 'area'
                       newid = "a%02d"%areacnt
                       areacnt += 1
                       area = MapArea(newid, coord, type=type)
                       print  "  adding: ", newid
                       msg += "  adding: "+newid+"\n"
                       col.addMapArea(area)
           msg += "\nDone!"
           return msg
   
   from ECHO_root import ECHO_main
   
   #class ECHO_main(ECHO_root,ECHO_navigation):
   #    """echo main object combines ECHO_root and ECHO_navigation"""
   #    
   #    meta_type="ECHO_main"
   #    
   #    def __init__(self,id,title):
   #        """init"""
   #        self.id=id
   #        self.title=title
   #        self.pathToHierarchy="/"+self.id # hierarchie always starts with the object.
   #        self.displayedMetaTypes=displayTypes
   #        
   #        
   #    manage_options = Folder.manage_options+(
   #        {'label':'Main Config','action':'ECHO_navigationConfigForm'},
   #        {'label':'Cache','action':'ECHO_cacheManageForm'},
   #        {'label':'Main Config','action':'ECHO_copyright_configForm'},
   #        {'label':'Change Weights','action':'changeWeights'},
   #        {'label':'Generate from RDF','action':'generateFromRDFForm'},
   #        {'label':'update Resource Catalog','action':'updateResourceCatalog'},
   #        {'label':'Copy MD for indexing and search','action':'copySearchFields'},
   #        )
   #
   #    
   #def manage_addECHO_mainForm(self):
   #    """Form for adding"""
   #    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)
   #    return pt()
   #
   #def manage_addECHO_main(self,id,title,RESPONSE=None):
   #    """Add an ECHO_main"""
   #    self._setObject(id,ECHO_main(id,title))
   #    
   #    obj=self._getOb(id)
   #    text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()
   #    
   #    manage_addPageTemplate(obj,'main_template',text=text)               
   #    
   #  
   #    if RESPONSE is not None:
   #        RESPONSE.redirect('manage_main')
Removed from v.1.77  
changed lines
  Added in v.1.310.2.12

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