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

version 1.142, 2004/07/18 14:14:42 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
Line 25  from Globals import DTMLFile Line 31  from Globals import DTMLFile
 import Globals  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 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
Line 43  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 *
   
 def getRDFDescription(self,linkURL,urn=None):  
         """rdf"""  
         ret=""  
         about="""<RDF:Description about="%s">"""  
         name="""<ECHONAVIGATION:name>%s</ECHONAVIGATION:name>"""  
         #link="""<ECHONAVIGATION:link>%s</ECHONAVIGATION:link>"""  
         link="""<ECHONAVIGATION:link RDF:about="%s"/>"""  
         type="""<ECHONAVIGATION:type>%s</ECHONAVIGATION:type>"""  
   
         if not urn:  
             urn="urn:"+re.sub('/',':',self.absolute_url())  
   
         about2=about%urn  
         if hasattr(self,'label') and not (self.label==""):  
             name2=name%urllib.quote(self.label)  
         elif not self.title=="":  
             name2=name%urllib.quote(self.title)  
         else:  
             name2=name%self.getId()  
               
         link2=link%urllib.quote(linkURL)  
         type2=type%self.meta_type  
           
         ret=about2+"\n"+name2+"\n"+link2+"\n"+type2+"\n</RDF:Description>"  
         return ret  
       
 def getCopyrightsFromForm(self,argv):   
     medias={}  
     partners={}  
     copyrights={}  
       
     copyrightsFinal=[]  
     for arg in argv.keys():  
           
         if arg[0:5]=='media':  
             nm=int(arg[5:])  
             medias[nm]=argv[arg]  
         elif arg[0:5]=='partn':  
             nm=int(arg[5:])  
             partners[nm]=argv[arg]  
         elif arg[0:5]=='copyr':  
             nm=int(arg[5:])  
             copyrights[nm]=argv[arg]  
   
   
   
     copyrightsList=[(medias[nm],partners[nm],copyrights[nm]) for nm in medias.keys()]  
     for copyright in copyrightsList:  
           
         if copyright[2]=='institution0000':  
             copyrightsFinal.append((copyright[0],copyright[1],self.getPartnerCopyright(copyright[1],'')))  
         else:  
             if not copyright[0]=='':  
                 copyrightsFinal.append(copyright)  
           
               
     return copyrightsFinal  
   
 #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)  
         self.referencetypes=tags[2]  
         self.fields=tags[3]  
           
       
         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:  
                       
                     diffs[self.getFieldTag(tags,field)]=0  
             except:              except:
                 diffs[self.getFieldTag(tags,field)]=0      print "no echo_language"
                       class ECHO_language:
         return diffs          """ leere Klasse"""
               pass
 def content_html(self,type):  
         """template fuer content"""  
         #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])  
         #  
         #if templates:  
         #    return templates[0][1]()  
       
         if hasattr(self,type+"_template"):  
             obj=getattr(self,type+"_template")  
             return obj()  
         else:  
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)  
             pt.content_type="text/html"  
             return pt()  
       
 def toList(field):  
     """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  
   
 class BrowserCheck:  from ECHO_movie import *
     """check the browsers request to find out the browser type"""  #import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
   import xmlrpclib
           
     def __init__(self, zope):  import logging
     self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")  
     self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and (string.find(self.ua, 'MSIE') < 0)  
     self.isIE = string.find(self.ua, 'MSIE') > -1  
     self.nav = self.ua[string.find(self.ua, '('):]  
     ie = string.split(self.nav, "; ")[1]  
     if string.find(ie, "MSIE") > -1:  
         self.versIE = string.split(ie, " ")[1]  
     self.isMac = string.find(self.ua, 'Macintosh') > -1  
     self.isWin = string.find(self.ua, 'Windows') > -1  
     self.isIEWin = self.isIE and self.isWin  
     self.isIEMac = self.isIE and self.isMac  
   
   from ECHO_root  import ECHO_root
   
   #ersetzt logging.info
   def logger(txt,method,txt2):
       """logging"""
       logging.info(txt+ txt2)
   
                   
 def writeMetadata(url,metadict,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):  def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs=""):
     """Einlesen der Metadaten und und erstellen des geaenderten XML file"""  
     def updateTextToolNode(tag,value):  
         #print dom,tag,value  
         metanode=dom.getElementsByTagName('texttool')[0]  
         try:  
             nodeOld=metanode.getElementsByTagName(tag)  
         except:  
             nodeOld=None  
               
         if nodeOld:  
             metanode.removeChild(nodeOld[0]).unlink()  
   
         node=dom.createElement(tag)  
         nodetext=dom.createTextNode(value)  
         node.appendChild(nodetext)  
         metanode.appendChild(node)  
   
               
     try:  
         geturl=""  
         for line in urllib.urlopen(url).readlines():  
             geturl=geturl+line  
           
           
     except:  
         return (None,"Cannot open: "+url)  
   
     try:  
         dom=xml.dom.minidom.parseString(geturl)  
     except:  
         return (None,"Cannot parse: "+url+"<br>"+geturl)  
   
     metanodes=dom.getElementsByTagName('bib')  
   
     if not metanodes:  
         metanodes=dom.getElementsByTagName('archimedes')  
   
     metanode=metanodes[0]  
   
     for metaData in metadict.keys():  
           
         try:  
             nodeOld=metanode.getElementsByTagName(metaData)  
         except:  
             nodeOld=None  
               
         if nodeOld:  
             metanode.removeChild(nodeOld[0]).unlink()  
         else:  
             # try also old writing rule - instead of _:  
             try:  
                 nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))  
             except:  
                 nodeOld=None  
                                   
             if nodeOld:          """Allegemeine Informationen zu einer ECHO Collection"""
                 metanode.removeChild(nodeOld[0]).unlink()  
   
         metanodeneu=dom.createElement(metaData)  
         try:  
             metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8"))  
         except:  
             metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8'))  
         metanodeneu.appendChild(metanodetext)  
         metanode.appendChild(metanodeneu)  
   
           self.label = label
           self.title=title
           self.description=description
           self.contentType=contentType
           self.responsible=responsible
           self.credits=toList(credits)
           self.weight=weight
   
   import ECHO_resource
   from ECHO_resource import manage_addECHO_resource
           
   class ECHO_resource(ECHO_resource.ECHO_resource):
       """depricated use class in ECHO_resource.py"""
           
           
     if project:  class ECHO_partner(Image,Persistent,ECHO_basis):
         updateTextToolNode('project',project)      """ECHO Partner"""
   
     if startpage:      meta_type="ECHO_partner"
         updateTextToolNode('startpage',startpage)  
   
     if topbar:      def __init__(self, id, title,url, file, copyrightType, person, email, country, color, content_type='', precondition=''):
         updateTextToolNode('toptemplate',topbar)          self.__name__=id
           self.title=title
           self.url=url
           self.person=person
           self.email=email
           self.country=country
           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 thumbtemplate:      manage_options = Image.manage_options+(
         updateTextToolNode('thumbtemplate',thumbtemplate)          {'label':'Partner Information','action':'ECHO_partner_config'},
           )
   
     if xslt:  
         updateTextToolNode('xslt',xslt)  
   
       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.toxml().encode('utf-8')  
   
       def ECHO_partner_config(self):
           """Main configuration"""
           if not hasattr(self,'url'):
               self.url=""
           pt=zptFile(self, 'zpt/ChangeECHO_partner.zpt')
           return pt()
           
           
 def readMetadata(url):  manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
     """Methode zum Auslesen der Metadateninformation zu einer Resource                               Kind='ECHO_partner',kind='ECHO_partner')
     Vorerst noch Typ bib"""  
           
     metadict={}  
     try:  
         geturl=""  
         for line in urllib.urlopen(url).readlines():  
             geturl=geturl+line  
                   
                   
     except:  def manage_addECHO_partner(self, id, url, person, email, country, color, file=None, copyrightType='', title='', precondition='', content_type='',
         return (None,"Cannot open: "+url)                      REQUEST=None):
       """
       Add a new ECHO_partner object.
   
     try:      Creates a new ECHO_partner object 'id' with the contents of 'file'.
         dom=xml.dom.minidom.parseString(geturl)      Based on Image.manage_addImage
     except:      """
         return (None,"Cannot parse: "+url+"<br>"+geturl)  
   
     metanode=dom.getElementsByTagName('bib')      id=str(id)
     metadict['bib_type']='Book'      title=str(title)
     if len(metanode)==0:      content_type=str(content_type)
         metanode=dom.getElementsByTagName('archimedes')      precondition=str(precondition)
         metadict['bib_type']='Archimedes'  
                   
       id, title = OFS.Image.cookId(id, title, file)
                   
     if not len(metanode)==0:          self=self.this()
         metacontent=metanode[0].childNodes  
           
         try:      # First, we create the image without data:
             metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)      self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, color, content_type, precondition))
         except:  
             """nothing"""  
                   
         for node in metacontent:      # Now we "upload" the data.  By doing this in two steps, we
             try:      # can use a database trick to make the upload more efficient.
             #print urllib.unquote(getText(node.childNodes)),getText(node.childNodes)      if file:
             metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes))          self._getOb(id).manage_upload(file)
             except:      if content_type:
                 """nothing"""          self._getOb(id).content_type=content_type
   
       if REQUEST is not None:
           try:    url=self.DestinationURL()
           except: url=REQUEST['URL1']
           REQUEST.RESPONSE.redirect('%s/manage_main' % url)
       return id
   
     return metadict,""  class ECHO_locale(ZopePageTemplate):
           """localisierung"""
           
           meta_type="ECHO_locale"
   
 def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):          def __init__(self,id,lang,title,label,text=None,content_type=None):
               self.lang=lang
               self.title=title
               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
   
         """Allegemeine Informationen zu einer ECHO Collection"""          manage_options = ZopePageTemplate.manage_options+(
                   {'label':'Main Config','action':'change_ECHO_localeForm'},
                   )
   
         self.viewClassification=viewClassification          def change_ECHO_localeForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_localeForm.zpt')
                   return pt()
   
         self.label = label          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')
   
                   
         if coordstrs:  def manage_addECHO_localeForm(self):
             for coordstr in coordstrs:           """Form for adding"""
            pt=zptFile(self, 'zpt/AddECHO_localeForm.zpt')
            return pt()
                   
                 try:  def manage_addECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
                     temco=coordstr.split(",")          """add echo locale"""
                 except:  
                     temco=[]  
                   
                 coords.append(temco)          id="locale_"+lang
   
           self._setObject(id, ECHO_locale(id,lang,title,label,text,content_type))
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
   
         self.coords=coords[0:]  
                           
 class ECHO_copyright(Folder):  class ECHO_copyright(Folder,ECHO_basis):
     """Copyright informationen"""      """Copyright informationen"""
     meta_type="ECHO_copyright"      meta_type="ECHO_copyright"
           
Line 400  class ECHO_copyright(Folder): Line 271  class ECHO_copyright(Folder):
         {'label':'Main Config','action':'ECHO_copyright_configForm'},          {'label':'Main Config','action':'ECHO_copyright_configForm'},
         )          )
   
   
     def ECHO_copyright_configForm(self):      def ECHO_copyright_configForm(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_copyright').__of__(self)                  pt=zptFile(self, 'zpt/ChangeECHO_copyright')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
Line 418  class ECHO_copyright(Folder): Line 290  class ECHO_copyright(Folder):
                   
 def manage_addECHO_copyrightForm(self):  def manage_addECHO_copyrightForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_copyright.zpt').__of__(self)      pt=zptFile(self, 'zpt/AddECHO_copyright.zpt')
     return pt()      return pt()
   
 def manage_addECHO_copyright(self, id,title,RESPONSE=None):  def manage_addECHO_copyright(self, id,title,RESPONSE=None):
Line 435  def manage_addECHO_copyright(self, id,ti Line 307  def manage_addECHO_copyright(self, id,ti
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
 class ECHO_layoutTemplate(ZopePageTemplate):  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 443  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 503  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_fullText(ZopePageTemplate,ECHO_basis,ECHO_language):
           """echo fulltext in xml"""
   
           meta_type="ECHO_fullText"
   
 class ECHO_resource(Folder,Persistent):  
     """ECHO Ressource"""  
     security=ClassSecurityInfo()  
     meta_type='ECHO_resource'  
   
     viewClassificationList=viewClassificationListMaster  
   
     getSubCols = ECHO_helpers.getSubCols  
   
     security.declareProtected('View','index_html')  
     def getRDF(self):  
         """rdf"""  
         return getRDFDescription(self,self.link)  
                   
           def getPage(self,nr='1'):
                   """get page n"""
                   #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')
                   
     def getAccessRightSelectorHTML(self,outlook="select"):                  return pages[int(nr)-1].toxml()
         """htmlselector"""  
         values=['free','mpiwg']  
                   
         if outlook=="select":  # Product registration and Add support
             ret="""<select name="%s">"""%self.getId()  manage_addECHO_fullTextForm = PageTemplateFile(
       'zpt/AddECHO_fullText.zpt', globals())
   
             for value in values:  def manage_addECHO_fullText(self, id, title=None, text=None,
                 if value==self.getAccessRightMD():                             REQUEST=None, submit=None):
                     ret+="<option selected>%s</option>"%value      "Add a Page Template with optional file content."
                 else:  
                     ret+="<option>%s</option>"%value  
             return ret+"</select>"  
   
       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:          else:
             ret=""          file = REQUEST.form.get('file')
             for value in values:          headers = getattr(file, 'headers', None)
                 print          if headers is None or not file.filename:
                 if value==self.getAccessRightMD():              zpt = ECHO_fullText(id)
                     ret+="""<input type="radio" name="%s" value="%s" checked>%s"""%(self.getId(),value,value)  
                 else:                  else:
                     ret+="""<input type="radio" name="%s" value="%s">%s"""%(self.getId(),value,value)              zpt = ECHO_fullText(id, file, headers.get('content_type'))
             return ret  
   
           self._setObject(id, zpt)
       
     def getAccessRightMD(self):  
         """set accessright"""  
         url=self.metalink  
   
         try:  
             geturl=""  
             for line in urllib.urlopen(url).readlines():  
                 geturl=geturl+line  
   
   
         except:  
             return (None,"Cannot open: "+url)  
   
         try:          try:
             dom=xml.dom.minidom.parseString(geturl)              u = self.DestinationURL()
             root=dom.getElementsByTagName('resource')[0]          except AttributeError:
         except:              u = REQUEST['URL1']
             return (None,"Cannot parse: "+url+"<br>"+geturl)  
   
         internal=dom.getElementsByTagName('internal')  
         if internal:  
             institution=dom.getElementsByTagName('institution')  
             return getText(institution[0].childNodes)  
           
         free=dom.getElementsByTagName('free')  
         if free:  
             return "free"  
   
         return "free" #default free  
   
     def changeAccessRightMD(self,accessright,RESPONSE=None):  
         """change the rights"""  
           
         params="accessright=%s"%accessright  
   
   
         #print urllib.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()  
   
           
         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()+'/setAccessRightXML'+urllib.quote('?'+params))).read()  
   
         
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
                   
     def setAccessRightXML(self,accessright):          if submit == " Add and Edit ":
         """set accessright"""              u = "%s/%s" % (u, urllib.quote(id))
         url=self.metalink          REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
         try:  
             geturl=""  
             for line in urllib.urlopen(url).readlines():  
                 geturl=geturl+line   
   
   
         except:  
             return (None,"Cannot open: "+url)  
   
         try:  class ECHO_externalLink(Folder,ECHO_basis):
             dom=xml.dom.minidom.parseString(geturl)      """Link zu einer externen Ressource"""
             root=dom.getElementsByTagName('resource')[0]      security=ClassSecurityInfo()
         except:      meta_type='ECHO_externalLink'
             return (None,"Cannot parse: "+url+"<br>"+geturl)  
   
         metanodes=dom.getElementsByTagName('access-conditions')      security.declarePublic('content_html')
       def content_html(self):
           """template fuer content"""
           ret= ECHO_basis.content_html(self,'externalLink')
   
         if not metanodes:          if type(ret) is StringType:
             nodenew=dom.createElement('access-conditions')              return ret.decode('utf-8')
             root.appendChild(nodenew)  
             metanode=nodenew  
         else:          else:
             metanode=metanodes[0]             return ret
   
         accesses=metanode.getElementsByTagName('access')  
   
         if not accesses:  
             nodenew2=dom.createElement('access')  
             metanode.appendChild(nodenew2)  
             metanode2=nodenew2  
         else:  
             metanode2=accesses[0]  
   
         internal=metanode.getElementsByTagName('internal')      def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType):
   
         if internal:          self.id = id
             metanode2.removeChild(internal[0]).unlink()          """Festlegen der ID"""
   
         free=metanode.getElementsByTagName('free')  
                   
         if free:          self.credits=toList(credits)
             metanode2.removeChild(internal[0]).unlink()          self.label = label
           self.link= link
           self.title=title
           self.weight=weight
           self.description=description
           self.contentType=contentType
           self.responsible=responsible
           coordsnew=[ string.split(x,",") for x in coords]
           self.coords=coordsnew
           self.linkType = linkType        # Linktypen 'otherPresentation','external'
   
   
         if accessright=='free':      def ECHO_externalLink_config(self):
             nodenew3=dom.createElement('free')          """Main configuration"""
             metanode2.appendChild(nodenew3)  
         elif accessright=='mpiwg':  
             nodenew3=dom.createElement('internal')  
             nodenew4=dom.createElement('institution')  
             metanodetext=dom.createTextNode('mpiwg')  
             nodenew4.appendChild(metanodetext)  
             nodenew3.appendChild(nodenew4)  
             metanode2.appendChild(nodenew3)  
   
         return dom.toxml().encode('utf-8')          if not hasattr(self,'weight'):
               self.weight=""
           if not hasattr(self,'coords'):
   
     def setStartPageForm(self):              self.coords=['']
         """Form for changing the startpage"""  
   
                   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resourceStartPage.zpt').__of__(self)          pt=zptFile(self, 'zpt/ChangeECHO_externalLink.zpt')
             pt.content_type="text/html"  
             return pt()              return pt()
           
           
     def setStartPage(self,startpage=None,RESPONSE=None):      def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
         """set start page, if no startpage defined use the generic one of the resource"""          """Aenderung der Properties"""
           setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
         if (not (type(startpage)==StringType)) and ("__generic" in startpage): # checke ob generic in der liste  
             startpage=self.absolute_url()+"/startpage_html"  
               
         if (not startpage) or (startpage=="__generic"):  
              startpage=self.absolute_url()+"/startpage_html"  
           
       
         params="startpage=%s"%startpage  
           
         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'+urllib.quote('?'+params))).read()  
       
           
         path=self.metalink  
           
         path=re.sub(self.REQUEST['SERVER_URL'],'',path)  
         path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)  
   
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server  
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server  
         path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server  
         path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server  
         path=re.sub('/index.meta','',path)   
   
   
         urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()  
   
           self.link=link
           self.linkType = linkType
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def changeViewerTemplateSetForm(self):      def getLinkType(self):
         """change the viewer template set"""          """ return linkType """
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeResourceViewerTemplateSet').__of__(self)          if hasattr(self,"linkType"):
             return pt()                  return self.linkType
           else :
                   return 'otherPresentation'
   
     def getTextToolsField(self,name,default=''):      def setLinkType(self,type):
         """Lese Textoolsfelder aus index.meta im path aus"""          """ set linkType """
           self.linkType = type
                   
       def checkLink(self):
           """ returns tuple (isWorking,Error) """        
         try:          try:
             dom=xml.dom.minidom.parse(self.metalink)              urllib2.urlopen(self.link)
             node=dom.getElementsByTagName('texttool')[0] #getNode              return (True, '')
             subnode=node.getElementsByTagName(name)[0]          except urllib2.HTTPError, e:
               return (False, e.code)
             # bei text wird nur der Folder gebraucht          except urllib2.URLError, e:
             if name=="text":              return (False, str(e.reason))
                 splitted=getText(subnode.childNodes).split("/")  
                 return splitted[len(splitted)-2]  
             else:  
                 return getText(subnode.childNodes)  
         except:          except:
             return default              return (False, 'unknown Error')
         
   
     def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,RESPONSE=None):      manage_options = (
         """changeit"""          {'label':'Main Config','action':'ECHO_externalLink_config'},
           {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
           )+Folder.manage_options
   
         paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate']  
   
       def index_html(self):
           """standard page"""
                   
         #writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)          return self.REQUEST.RESPONSE.redirect(self.link)
   
         params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate)  
   
   def manage_addECHO_externalLinkForm(self):
           """Form for external Links"""
           pt=zptFile(self, 'zpt/AddECHO_externalLinkForm.zpt')
           return pt()
                   
         urllib.urlopen('http://echo.mpiwg-berlin.mpg.de/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()  
   
         # hack Pfad auf die Dokumente  def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
         path=self.metalink      """Add an external Link"""
                   
       newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
                   
       self._setObject(id,newObj)
   
         path=re.sub('/index.meta','',path)       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
         path=re.sub(self.REQUEST['SERVER_URL'],'',path)  
         path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)  
   
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server  class ECHO_link(ECHO_externalLink):
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server          """external_link"""
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server  
   
         path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server          meta_type="ECHO_link"
         path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server  
   
         return urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()          manage_options = ECHO_externalLink.manage_options+(
                   {'label':'add links config','action':'ECHO_link_addLinksForm'},
                   )
   
         if RESPONSE is not None:          def getMDValueSimpleSearchField(self):
             RESPONSE.redirect('manage_main')            """returns value for simple search"""
             return " ".join([self.getTitle(),self.getDescription()])
   
           def ECHO_link_addLinksForm(self):
               """Main configuration"""
           
     def getTitle(self):              pt=zptFile(self, 'zpt/ChangeECHO_link_addLinks.zpt')
     """title"""              return pt()
     try:  
         return self.title.encode('utf-8','ignore')   
     except:  
         self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error  
         return self.title.encode('utf-8','ignore')   
           
     def getLabel(self):          def ECHO_link_addLinks(self,addLinks,RESPONSE):
     """title"""              """add links"""
     try:              self.addLinks=addLinks
         return self.label.encode('utf-8','ignore')               if RESPONSE is not None:
     except:                  RESPONSE.redirect('manage_main')
         self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error  
         return self.label.encode('utf-8','ignore')   
           
     def content_html(self):      def content_html(self):
         """template fuer content"""                  """template fuer link"""
         return content_html(self,'resource')  
           
     def getViewClassification(self):  
         if hasattr(self,'viewClassification'):  
             return self.viewClassification  
         else:  
             return ""  
   
     def getFullTextXML(self,noredirect=None):                  if hasattr(self,"link_template"):
         """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""                          ret=ECHO_basis.content_html(self,'link')
         try:  
             fh=urllib.urlopen(self.metalink)  
             dom=xml.dom.minidom.parse(fh)  
             texttools=dom.getElementsByTagName('texttool')  
             text=texttools[0].getElementsByTagName('text')  
             texturl=getText(text[0].childNodes)  
                           
             if not noredirect:  
                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')    
                 self.REQUEST.RESPONSE.redirect(texturl)  
             else:              else:
                 return texturl                          ret=ECHO_basis.content_html(self,'collection')
         except:  
   
             if not noredirect:  
                 self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
                 self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")  
             else:  
                 return "<error>no fulltext available</error>"  
   
                   #return ret
                   return ret
   #            
   #            
   #                try:
   #                    return ret.decode('utf-8')
   #                except:
   #                    try: 
   #                        return ret.decode('latin-1')
   #                    except:
   #                
   #                        return ret
   #        
     def getCopyrightsHTML(self):      def getCopyrightsHTML(self):
         """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""          """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
                   
Line 812  class ECHO_resource(Folder,Persistent): Line 594  class ECHO_resource(Folder,Persistent):
             return "ERROR"              return "ERROR"
         ret=[]          ret=[]
                   
         for copyright in obj.getCopyrights():              for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
                           
             link="copyrightTypes/"+copyright[2]+'/copyright.html'  
                           
             try:              try:
                           if hasattr(self.copyrightTypes,copyright[2]):
                 copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])                  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                  label=copyrightTypeObj.label
                 url=copyrightTypeObj.url                          url=getattr(copyrightTypeObj, 'url', '')
                                   
                 if url!='':                  if url!='':
                      ret.append((url,copyright[0],copyright[1],copyright[2],label))                       ret.append((url,copyright[0],copyright[1],copyright[2],label))
Line 833  class ECHO_resource(Folder,Persistent): Line 620  class ECHO_resource(Folder,Persistent):
                           
         return ret          return ret
           
     def getCredits(self):          def getInstitutionsHTML(self):
         """Ausgabe der credits"""                  """gibt Liste der foerdernden Institutionen aus"""
         if self.credits:                  
             return self.credits                  if hasattr(self,'support'):
                           obj=self.support
                           ret=obj.getSupporter()
                           return ret
         else:          else:
             return []                          return ''
           
     def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):          def getOwnerOriginalsHTML(self):
                  """gibt Liste der foerdernden Institutionen aus"""
   
         self.id = id                 if hasattr(self,'ownerOriginal'):
         """Festlegen der ID"""                         obj=self.ownerOriginal
                          ret=obj.getOwner()
                          return ret
                  else:
                          return ''
                   
         self.label = label          def getDigiCopyByHTML(self):
         self.link= link                 """gibt Liste der foerdernden Institutionen aus"""
         self.metalink=metalink  
         self.title=title  
         self.weight=weight  
         self.credits=toList(credits)  
         self.description=description  
         self.contentType=contentType  
     self.copyrightType=copyrightType  
     self.renderingType=renderingType  
         self.responsible=responsible  
         self.resourceID=resourceID  
           
         if coords:                 if hasattr(self,'digiCopyBy'):
             coordsnew=[ string.split(x,",") for x in coords]                         obj=self.digiCopyBy
                          ret=obj.getDigiCopyBy()
                          return ret
         else:          else:
             coordsnew=[]                         return ''
                   
         self.coords=coordsnew          def index_html(self):
                   """standard link"""
                   if self.link:
                    splitted=self.link.split("?")
                    if len(splitted)>1:
                           params=cgi.parse_qs(splitted[1])
   
                           for x in params.keys():
                                   if type(params[x]) is ListType:
                                           params[x]=params[x][0]
   
     def getCoords(self):  
         """gibt coordinaten als String zurück und löscht zugleich einträge die keine Koordinaten sind, letzteres zur korrektur der Eingabe der alten version"""  
         retList=[]  
         if hasattr(self,'coords'):  
             for x in self.coords:  
             if len(x)>1:  
                 retList.append(string.join(x,","))  
         return retList  
   
                    else:
                           params={}
           
                    if getattr(self,'addLinks','yes')=="yes":
                        params['backLink']=self.aq_parent.absolute_url()
                        params['startLink']=splitted[0]+"?"+urllib.urlencode(params)
   
     def getContentType(self):  
         try:  
             return self.contentType  
         except:  
             return ""  
   
     def getCopyrightType(self):                   return self.REQUEST.RESPONSE.redirect(splitted[0]+"?"+urllib.urlencode(params))
         try:                  else:
             return self.copyrightType  
         except:  
             return ""  
   
     def getRenderingType(self):  
         try:  
             return self.renderingType  
         except:  
             return ""              return ""
   
     def ECHO_resource_config(self):  def manage_addECHO_linkForm(self):
         """Main configuration"""          """Form for external Links"""
           pt=zptFile(self, 'zpt/AddECHO_linkForm.zpt')
         if not hasattr(self,'weight'):  
             self.weight=""  
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)  
         return pt()  
       
   
     def ECHO_resource_config_main(self):  
         """Main configuration"""  
   
         if not hasattr(self,'weight'):  
             self.weight=""  
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)  
         return pt()  
   
     def ECHO_resource_config_coords(self):  
         """Coords configuration """  
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_coords.zpt').__of__(self)  
         return pt()  
   
     def ECHO_resource_config_credits(self):  
         """Main configuration"""  
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)  
         return pt()  
   
     def ECHO_resource_config_metadata(self):  
         """Main configuration"""  
   
     if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):  
         self.metaDataHash={}  
         self.contentType=self.bib_type  
         for data in self.metadata:  
             data_neu=re.sub('-','_',data)  
             self.meta  
                         DataHash[data_neu]=getattr(self,data)[0:]  
   
       
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)  
         return pt()          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)
   
     def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):      self._setObject(id,newObj)
         """Änderung der Properties"""  
     self.resourceID=resourceID  
     self.title=title  
     self.label=label  
     self.description=description  
   
     self.contentType=contentType  
     self.renderingType=renderingType  
     self.weight=weight  
           
         self.link=link      getattr(self,id).addLinks='no'
         self.metalink=metalink  
                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):  class ECHO_collection(CatalogAware, Folder, Persistent, Implicit, Cacheable,ECHO_basis):
         """Änderung der Properties - coords"""      """ECHO Collection"""
   
     if type(coords)==StringType:  
             coords=[coords]  
   
         try:          
             coordsnew=[ string.split(x,",") for x in coords]  
         except:  
         coordsnew=[]      
   
     self.coords=coordsnew[0:]  
     self.viewClassification=viewClassification  
                   
         if RESPONSE is not None:      management_page_charset="utf-8"
             RESPONSE.redirect('manage_main')      security=ClassSecurityInfo()
       meta_type='ECHO_collection'
       default_catalog='resourceCatalog'
   
     def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):      rootMetaTypes = ['ECHO_root', 'ECHO_main', 'ECHO_nav']
         """Änderung der Properties"""  
     self.credits=credits  
     self.responsible=responsible  
     self.copyrightType=copyrightType  
           
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
   #    viewClassificationList=viewClassificationListMaster
       displayTypes=displayTypes
   
     def changeECHO_resource_metadata_local(self,RESPONSE=None):      path="/mpiwg/online/permanent/shipbuilding"
         """change metadata"""  
         tags=self.findTagsFromMapping(self.contentType)  
         for field in tags[1]:  
             self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]  
                           
       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()
   
       def importObjects_html(self,RESPONSE):
           """ImportObject"""
           pt=zptFile(self, 'zpt/importObjects.zpt')
           pt.content_type="text/html"
           return pt()
                                   
         if RESPONSE is not None:      def importObjects(self,zfile,RESPONSE=None,REQUEST=None):
             RESPONSE.redirect('manage_main')          """import object from file"""
   
     def changeECHO_resource_metadata(self,RESPONSE=None):          zf=zipfile.ZipFile(zfile,"r")
         """change metadata"""          tmpdir=tempfile.mkdtemp() # create tempdir
         tags=self.findTagsFromMapping(self.contentType)          ret=None
         self.OSAS_meta={}          
         for field in tags[1]:          for name in zf.namelist():
                  ds,fn=tempfile.mkstemp()
                  tf=file(fn,"w")
                  x=zf.read(name)
                  tf.write(x)
                  tf.close()
             try:              try:
                 self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]                     self._importObjectFromFile(fn,set_owner=1)
                 self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]  
             except:              except:
                 """nothing"""                     if not ret:
                          ret=""
         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()                     ret+="Cannot import: %s (Already existing?)<br>"%name
              os.close(ds)
                  os.remove(fn)
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
   
     def getMDValue(self,fieldName):          zf.close()
         return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)  
                                             
     def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):          if ret:
         """new index.meta"""              return """<html><body>%s</body></html>"""%ret
         self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')          if RESPONSE:
               RESPONSE.redirect(self.absolute_url())
   
         if not hasattr(self,'metaDataHash'):      def exportObjects_html(self,RESPONSE):
           """Export objects"""
                   
             self.copyIndex_meta2echo_resource()          pt=zptFile(self, 'zpt/exportObjects.zpt')
         try:          pt.content_type="text/html"
             return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate)          return pt()
         except:  
             return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate)  
   
     def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):      def exportObjects(self,ids,RESPONSE=None):
         """prints out metadata as stored in the echo environment, format is the index.meta format"""          """export objects with type id"""
         self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')          if not (type(ids) is ListType):
         return writeMetadata(self.metalink,self.metaDataHash)              ids=[ids]
   
     def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):          tmpdir=tempfile.mkdtemp() # create tempdir
         """Änderung der Properties"""          objs=self.ZopeFind(self,obj_ids=ids)
           tmpfile=tempfile.mkstemp()[1]
                   
     try:                  zf=zipfile.ZipFile(tmpfile,"w")
             coordsnew=[ string.split(x,",") for x in coords]          for obj in objs:
         except:  
         coordsnew=[]      
                   
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)              f = os.path.join(tmpdir, '%s.zexp' %obj[0])
     self.viewClassification=viewClassification              #print E.absolute_url()
         self.coords=coordsnew[0:]  
         self.link=link  
         self.metalink=metalink  
                   
         if RESPONSE is not None:              obj[1]._p_jar.exportFile(obj[1]._p_oid, f)
             RESPONSE.redirect('manage_main')  
                           
               zf.write(f,obj[0])
                           
     manage_options = Folder.manage_options+(          zf.close()
         {'label':'Main Config','action':'ECHO_resource_config_main'},          shutil.rmtree(tmpdir)
     {'label':'Change Metadata','action':'ECHO_resource_config_metadata'},          if RESPONSE:
     {'label':'Change Coords','action':'ECHO_resource_config_coords'},              RESPONSE.setHeader("Content-Type","application/octet-stream")
     {'label':'Add coords','action':'ECHO_graphicEntry'},              len=os.stat(tmpfile)[6]
         {'label':'Sync Metadata','action':'ECHO_getResourceMD'},              RESPONSE.setHeader("Content-Length",len)
     {'label':'Change TemplateSets','action':'changeViewerTemplateSetForm'},              RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"export.zip")
     {'label':'set/change startpage','action':'setStartPageForm'},              fh=file(tmpfile)
     {'label':'Copy MD for indexing and search','action':'copySearchFields'},              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:
   
     def getOverview(self):                      if content[1].meta_type in ['ECHO_link','ECHO_externalLink']:
         """overview graphics"""  
                   
         return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]                              find=content[1].ZopeFind(content[1],obj_metatypes=('ECHO_mapText'))
                               if find:
                                       root=find[0][1]
   
     def ECHO_graphicEntry(self):                                      locale=find[0][1].ZopeFind(find[0][1],obj_ids=('locale_en'))
         """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:          else:
             return "NO OVERVIEW GRAPHICS"                                      root=None
                       else:
     def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):                              root=content[1]
         """Enter coords"""                              locale=content[1].ZopeFind(content[1],obj_ids=('locale_en'))
         coords=self.coords                      if root and not locale:
         temco=coordstr.split(",")                              root.manage_addECHO_locale("en",'','')
         temco.append(angle)  
         coords.append(temco)  
                   
         self.coords=coords[0:]              pt=zptFile(self, 'zpt/localizeObjects.zpt')
               return pt()
   
         if RESPONSE is not None:  
             RESPONSE.redirect('ECHO_graphicEntry')  
   
       def localize(self,REQUEST,RESPONSE):
               """localize"""
               for key in REQUEST.form.keys():
                       splitted=key.split("!")
   
     def isDefinedInThisSet(self,fields,field):                      if splitted[0]=="" or splitted[0]=="en" or splitted[0]=="title" or splitted[0]=="label":
         """checks if field is defined in fields"""                              if splitted[0]=="en":
         if (fields[0].has_key(field)) and not (fields[0][field]==""):                                      setattr(self.locale_en,splitted[1],REQUEST.form[key])
             return 1  
         else:          else:
                                                 setattr(self,splitted[0],REQUEST.form[key])
             return 0  
           
     def getFieldLabel(self,fields,field):  
         """get labels"""  
         try:  
             ret =fields[0][field]  
             if ret == "":  
                 return field  
             else:              else:
                 return ret                              obj=getattr(self,splitted[0])
         except:  
             return field  
   
   
   
     def getFieldTag(self,fields,field):                              if obj.meta_type=="ECHO_mapText":
         """get labels"""                                      if splitted[1]=="en":
         try:                                              obj.locale_en.pt_edit(REQUEST.form[key],obj.locale_en.content_type)
             ret =fields[0][field]  
             if ret == "":  
                 return field  
             else:              else:
                 return ret                                              obj.pt_edit(REQUEST.form[key],obj.content_type)
         except:  
             return field  
   
       
           
     def getFieldValue(self,field):  
         """get value"""  
       
         try:  
       
             ret=self.metaDataHash[field]  
             if ret == "":  
                 return None  
             else:              else:
                 return ret                                      text=obj.ZopeFind(obj,obj_metatypes=['ECHO_mapText'])
         except:                                      if splitted[1]=="en":
             return None  
   
     def getMetaDataHash(self):  
         """md hash"""  
         return self.metaDataHash  
       
     def setFieldValue(self,field,value):  
         """get value"""  
       
     if not hasattr(self,'metaDataHash'):  
         setattr(self,'metaDataHash',{})  
     self.metaDataHash[field]=value[0:]  
       
   
     def copySearchFields(self):  
         """copys metadatafields to the object"""  
         fields=['author','title','year']  
         for field in fields:  
             setattr(self,'MD_'+field,self.getFieldValue(field))  
           
                                               text[0][1].locale_en.pt_edit(REQUEST.form[key],text[0][1].locale_en.content_type)
                                       else:
                                               text[0][1].pt_edit(REQUEST.form[key],text[0][1].content_type)
               if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
     def findLabelsFromMapping(self,referenceType):  
         """gib hash mit label -> generic zurueck"""  
     #return {},[]  
   
         temp=self.ZopeFind(self.standardMD)      def getRDF(self,urn=None):
               """rdf of the collection"""
   
     if referenceType=="":              contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
         referenceType="book"  
           
               ret=getRDFDescription(self,self.absolute_url(),urn=urn)
           
         bibdata={}              if not urn:
         retdata={}                      urn=self.absolute_url()
     fields=[]  
         fieldlist=self.standardMD.fieldList  
                   
     for referenceTypeF in self.referencetypes:              li="""<rdf:li rdf:resource="%s" />\n"""
   
         if referenceTypeF[1].title.lower() == referenceType.lower():  
   
               for content in contents:
             try:              try:
                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields                      ret+=content[1].getRDF()+"\n"
                 referenceType=referenceTypeF[1].title  
             except:              except:
                 bibdata[referenceType]=referenceTypeF[1].fields              logging.error("getrdf: "+repr(content[1].getRDF()))
           
   
             bibdata['data']=referenceTypeF[1]  
             fields=bibdata[referenceType]  
                         for field in fieldlist:  
                             retdata[field]=referenceTypeF[1].getValue(field)[1]  
   
         return retdata,fieldlist,temp,fields  
   
     def findTagsFromMapping(self,referenceType):  
         """gib hash mit label -> generic zurueck"""  
       
   
     if referenceType=="":  
         referenceType="book"  
       
     temp =  self.ZopeFind(self.standardMD)[0:]  
   
       
     #self.referencetypes=temp[0:]  
       
       
       
   
       
   
         bibdata={}  
         retdata={}  
         fieldlist=self.standardMD.fieldList  
         fields=[]  
     for referenceTypeF in temp:  
         #print referenceType  
       
         if referenceTypeF[1].title.lower() == referenceType.lower():   
             try:              try:
                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields                  ret+=self.unicodify(content[1].getRDF())+"\n"
                 referenceType=referenceTypeF[1].title  
             except:              except:
                 bibdata[referenceType]=referenceTypeF[1].fields              logging.error("--still cannot do it")
             bibdata['data']=referenceTypeF[1]                  ret+=repr(content[1].getRDF())+"\n"
             fields=bibdata[referenceType]              ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
                         for field in fieldlist:              for content in contents:
                             retdata[field]=referenceTypeF[1].getValue(field)[0]                      nurn=content[1].absolute_url()
                           ret+=li%nurn
         return retdata,fieldlist,temp,fields              return ret+"</rdf:Seq>"
   
       
     security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination  
     def copyIndex_meta2echo_resource(self,RESPONSE=None):  
         """copy MD von Index_meta to the echo_resource"""  
           
         (metadict, error)=readMetadata(self.metalink)  
   
   
           
         self.metaDataHash={}  
         if not error=="": #Fehler beim Auslesen des Metafiles  
               
             return "ERROR:",error  
           
         self.contentType=metadict['bib_type'][0:]  
         fields=self.findTagsFromMapping(self.contentType)  
           
         #fields=self.findLabelsFromMapping(self.contentType)  
         for field in fields[1]:  
               
             if self.isDefinedInThisSet(fields,field):  
                 #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))  
                 self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))  
   
           
           
         if RESPONSE:  
             return RESPONSE.redirect('manage_main')  
           
     def ECHO_getResourceMD(self,template="yes",back=None):  
         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""  
         (metadict, error)=readMetadata(self.metalink)  
   
         if back:  
             self.REQUEST.SESSION['back']=back  
   
         if not error=="": #Fehler beim Auslesen des Metafiles  
         return "ERROR:",error  
       
   
     if not (metadict['bib_type'].lower()==self.contentType.lower()):  
         self.REQUEST.SESSION['contentStorage']=metadict['bib_type']  
         self.REQUEST.SESSION['contentZope']=self.contentType  
   
         return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()  
   
     self.REQUEST.SESSION['metadict']=metadict  
   
           
           
     self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])      def getExportCollectionsAsJSON(self,metatypes=['ECHO_resource'],REQUEST=None):
           import json
           ret = self.getExport(metatypes=metatypes)
           
           if REQUEST:
                   REQUEST.response.setHeader("Content-type", "text/json; charset=utf-8")
   
           return json.dumps(ret)
                   
         if template=="yes":      def getExport(self,metatypes=['ECHO_resource'],REQUEST=None):
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)  
         return pt()  
   
               """JSON export collection content"""
               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(),'')
   
           
               for content in contents:
           
     def ECHO_getMD(self,item):                  ret['content'].append(content[1].getDRI(type="mpiwg"))
         """Ausgabe der MD"""  
         return getattr(self,item)  
                   
     def index_html(self):              return ret
         """standard page"""  
                   
         return self.REQUEST.RESPONSE.redirect(self.link)  
   
     def startpage_html(self):  
         """prints out a startpage for a resource for use e.g. in the BVE"""  
   
         # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt      def getDRI(self,type="escidoc"):
           """sofar cho collections don't have dris
           therefore return the path"""
   
         sp=self.ZopeFind(self,obj_ids=['startpage.html'])          return self.absolute_url().replace(self.echo_pages.absolute_url(),'')
   
         if sp:  
             return sp[1]()  
   
             #prüfen ob irgendwo ein template  
         if hasattr(self,'startpage_index_template'):   
             return self.startpage_index_template()  
   
         #generisches template ausgeben  
                   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_startpage_index_template_standard.zpt').__of__(self)      def changeLabels(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/changeLabelsForm')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
     def toc_html(self):      def changeTitles(self):
                           """change form"""
         sp=self.ZopeFind(self,obj_ids=['toc.html'])                  pt=zptFile(self, 'zpt/changeTitleForm')
                               pt.content_type="text/html"
         if sp:  
             return sp[0][1]()  
   
   
     security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination  
   
     def generate_label(self):  
         """Erzeugt_standard_Label aus Template"""  
         pt=getattr(self,"label_template_"+self.contentType.lower())  
   
     self.label=pt()[0:]  
         return pt()          return pt()
   
     security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination      def changeWeights(self):
                   """change form"""
     def generate_title(self,RESPONSE=None):                  pt=zptFile(self, 'zpt/changeWeightForm')
         """Erzeugt_standard_Label aus Template"""                  pt.content_type="text/html"
         pt=getattr(self,"label_template_"+self.contentType.lower())  
   
     self.title=pt()[0:]  
       
         return pt()          return pt()
   
 Globals.InitializeClass(ECHO_resource)      def changeMetaDataLinks(self):
                   """change form"""
 def manage_addECHO_resourceForm(self):                  pt=zptFile(self, 'zpt/changeMetaDataLinkForm')
         """Form for adding a ressource"""                  pt.content_type="text/html"
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)  
         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,responsible,link,metalink,weight,copyrightType=None,resourceID=None,contentType=None,renderingType=None,credits=None,coords=None,RESPONSE=None):  
     """addaresource"""  
   
     newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)  
   
     self._setObject(id,newObj)      def changeAccessRightsCollection(self):
               """change"""
               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:
     
                       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
   
 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:
     try:  
         return self.title.encode('utf-8','ignore')   
     except:  
         self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error  
         return self.title.encode('utf-8','ignore')   
           
     def getLabel(self):  
     """title"""  
     try:      try:
         return self.label.encode('utf-8','ignore')                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].metalink=argv[resource[1].getId()][0:]
     except:      except:
         self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error                              pass
         return self.label.encode('utf-8','ignore')               return ret
   
     def content_html(self):  
         """template fuer content"""  
         return content_html(self,'externalLink')  
       
     def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):  
   
         self.id = id  
         """Festlegen der ID"""  
   
         self.credits=toList(credits)  
         self.label = label  
         self.link= link  
         self.title=title  
         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):  
         """Main configuration"""  
   
         if not hasattr(self,'weight'):  
             self.weight=""  
         if not hasattr(self,'coords'):  
               
             self.coords=['']  
   
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)  
         return pt()  
           
       def changeMetaDataLinkInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
   
     def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
               for resource in resources:
   
         """Änderung der Properties"""  
     try:      try:
         coordsnew=[ string.split(x,",") for x in coords]                              ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].metalink=argv[resource[1].getId()][0:]
     except:      except:
         coordsnew=[]                              pass
   
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)  
   
         self.coords=coordsnew[0:]  
         self.link=link  
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
               
               
     manage_options = Folder.manage_options+(  
         {'label':'Main Config','action':'ECHO_externalLink_config'},  
         )  
   
           
     def index_html(self):  
         """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 manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):  
     """Add an external Link"""  
   
     newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)  
   
     self._setObject(id,newObj)  
   
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
    
   
 class ECHO_link(ECHO_externalLink):  
     """external_link"""  
   
     meta_type="ECHO_link"  
       
   
     def content_html(self):  
         """template fuer link"""  
         if hasattr(self,"link_template"):  
             return content_html(self,'link')  
         else:  
             return content_html(self,'collection')  
       
 def manage_addECHO_linkForm(self):  
         """Form for external Links"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)  
         return pt()  
   
   
 def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):  
     """Add an external Link"""  
   
     newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)  
   
     self._setObject(id,newObj)  
   
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
       
   
 class ECHO_collection(Folder, Persistent, Implicit):  
     """ECHO Collection"""  
   
     security=ClassSecurityInfo()  
     meta_type='ECHO_collection'  
     viewClassificationList=viewClassificationListMaster  
     displayTypes=displayTypes  
   
     path="/mpiwg/online/permanent/shipbuilding"  
   
     def showRDF(self):  
         """showrdf"""  
             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
         ret="""<?xml encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"  xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""  
         ret+=self.getRDF(urn="echo:collectionroot")+"\n"  
         ret+="""</RDF:RDF>"""  
             return ret               return ret 
   
     def getRDF(self,urn=None):      def changeWeightsInCollection(self):
         """rdf of the collection"""              """change all lables of a collection"""
         contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])  
   
         ret=getRDFDescription(self,self.absolute_url(),urn)  
   
         if not urn:  
             urn="urn:"+re.sub('/',':',self.absolute_url())  
         else:  
             urn="urn:"+urn  
               
         li="""<RDF:li resource="%s" />\n"""  
   
           
         for content in contents:  
             ret+=content[1].getRDF()+"\n"  
               
         ret+="""<RDF:Seq about="%s">\n"""%urn  
         for content in contents:  
             nurn="urn:"+re.sub('/',':',content[1].absolute_url())  
             ret+=li%nurn  
         return ret+"</RDF:Seq>"  
           
           
     def changeLabels(self):  
         """change form"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeLabelsForm').__of__(self)  
         pt.content_type="text/html"  
         return pt()  
   
     def changeTitles(self):  
         """change form"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeTitleForm').__of__(self)  
         pt.content_type="text/html"  
         return pt()  
   
     def changeAccessRightsCollection(self):  
         """change"""  
         ret=""          ret=""
         argv=self.REQUEST.form          argv=self.REQUEST.form
                   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
         for resource in resources:          for resource in resources:
                         
             try:              try:
                 ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"                  ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                 resource[1].changeAccessRightMD(argv[resource[1].getId()])                              resource[1].weight=argv[resource[1].getId()][0:]
             except:              except:
                 """not"""                              pass
         return ret          return ret
   
     def changeLabelsInCollection(self):      def changeTitlesInCollection(self):
         """change all lables of a collection"""          """change all lables of a collection"""
         ret=""          ret=""
         argv=self.REQUEST.form          argv=self.REQUEST.form
                   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
         for resource in resources:          for resource in resources:
                         
             try:              try:
                 ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"                  ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                             resource[1].label=argv[resource[1].getId()][0:]                              resource[1].title=argv[resource[1].getId()][0:]
             except:              except:
                 """not"""                              pass
         return ret          return ret
   
     def changeTitlesInCollection(self):      def changeLabelsInCollection(self):
         """change all lables of a collection"""          """change all lables of a collection"""
         ret=""          ret=""
         argv=self.REQUEST.form          argv=self.REQUEST.form
                   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
         for resource in resources:          for resource in resources:
                         
             try:              try:
                 ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"                  ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                             resource[1].title=argv[resource[1].getId()][0:]                              resource[1].label=argv[resource[1].getId()][0:]
             except:              except:
                 """not"""                              pass
         return ret          return ret
                   
     def updateCollection(self,RESPONSE=None):      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"""          """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
         files=os.listdir(self.path)          
           if path is None:
                   pt=zptFile(self, 'zpt/importCollection.zpt')
                   return pt()
   
           files=os.listdir(path)
     ret=""      ret=""
         for fileName in files:          for fileName in files:
                           
             if fileName:              if fileName:
                   
         tempPath=re.sub("/mpiwg/online","",self.path)                  if (replacePathExperimental and replacePathExperimental!=''):
         link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"                      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=self.path+"/"+fileName+"/index.meta"                  metalink=metaDataUrl+"/"+path+"/"+fileName+"/index.meta"
                 try:                  try:
   
             #link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"              #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,'generated','book','','','','','','')                          newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'','book','','','','','','')
             self._setObject(fileName,newObj)              self._setObject(fileName,newObj)
                                   
             genObj=getattr(self,fileName)              genObj=getattr(self,fileName)
Line 1626  class ECHO_collection(Folder, Persistent Line 1132  class ECHO_collection(Folder, Persistent
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def updateCollectionMD(self,RESPONSE=None):  
         """updateMD"""  
         files=os.listdir(self.path)  
         for fileName in files:  
             if fileName:  
                 genObj=getattr(self,fileName)  
                 genObj.copyIndex_meta2echo_resource()  
                 genObj.generate_title()  
   
         if RESPONSE is not None:      def changeViewerForm(self):
             RESPONSE.redirect('manage_main')              """change the viewer template set"""
               pt=zptFile(self, 'zpt/changeECHOViewer')
               return pt()
   
       def getTextToolsField(self,name,default=''):
               """Lese text tool field  der Collection not implemented yet!"""
   
               return default
   
     def changeViewerTemplateSetsForm(self):  
         """change the viewer template set"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeViewerTemplateSet').__of__(self)  
             return pt()  
   
     def getViewerTemplateSets(self,obj_ids=None):  
         """Get the ViewerTemplateSet title for configuration"""  
         ret=[]  
                   
         try:      def changeViewer(self,newViewer,REQUEST=None,RESPONSE=None):
             viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.          """changes all ressources to the newViewer"""
           
           resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
           if RESPONSE is not None:
                       RESPONSE.write("<html><body>")
                           
             for viewerTemplateSet in viewerTemplateSets:          for resource in resources:
                 ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))  
                                   
             return ret              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))
                           
         except:  
             return [('no ViewerTemplateSetfolders','')]  
   
     def getTextToolsField(self,name,default=''):  
         """Lese viewerTemplateSet der Collection not implemented yet!"""  
                   
         return default          if RESPONSE is not None:
                       RESPONSE.write("<p>Done</p></body></html>")
   
                           
     def isSelectedViewerTemplateSet(self,obj,id):  
         """is ausgewählt"""  
                   
         if self.REQUEST['viewerTemplateSet']==id:      def copyTitleToInfoXMLFolder(self,RESPONSE=None):
             return 1              """copy title into the title field of info.xml
         else:              author and date werden leer!!!
             return None              """
   
     def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,RESPONSE=None):  
         """change the templates"""  
   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
         for resource in resources:  
   
             resource[1].changeViewerTemplateSet(project,xslt,thumbtemplate,topbar,digiLibTemplate)              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)
   
                       #logger("ECHO (copyTitleToInfoXMLFolder)",logging.INFO,txt)   
         if RESPONSE is not None:          if RESPONSE is not None:
                       RESPONSE.write("done!\n")
                       RESPONSE.close()
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def copySearchFields(self,RESPONSE=None):      def copySearchFields(self,RESPONSE=None):
         """copys import metadatafields to the object"""              """copys < metadatafields to the object"""
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
         for resource in resources:          for resource in resources:
   
Line 1698  class ECHO_collection(Folder, Persistent Line 1202  class ECHO_collection(Folder, Persistent
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def reloadMetaDataFromStorage(self,RESPONSE=None):  
         """copy metadata from the storage to ECHO"""  
         ret=""  
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])  
   
         for resource in resources:  
   
             ret+=str(resource[1].copyIndex_meta2echo_resource())+"<br>"  
   
   
         if RESPONSE is not None:  
             #           RESPONSE.redirect('manage_main')  
             return ret  
           
     def getPartnerCopyright(self,name,sonst="generic"):      def getPartnerCopyright(self,name,sonst="generic"):
         """gibt generisches copyright eines partners aus, sonst behalte jetzige einsteillung"""          """gibt generisches copyright eines partners aus, sonst behalte jetzige einsteillung"""
         #print "hi",name,sonst          #print "hi",name,sonst
Line 1731  class ECHO_collection(Folder, Persistent Line 1223  class ECHO_collection(Folder, Persistent
          retStr="<option>\n"           retStr="<option>\n"
                     
      try: # erste version copyrightTypes exists       try: # erste version copyrightTypes exists
          for partner in self.credits:                   for partner in self.getPartners():
              if selected and (partner==selected):                           partnerTitle = partner.title
                  retStr+="""<option selected value="%s">%s\n"""%(partner,partner)                           partnerId = partner.__name__
                            if selected and (partnerId==selected):
                                    retStr+="""<option selected value="%s">%s\n"""%(partnerId,partnerTitle)
              else:                               else:                
                  retStr+="""<option value="%s">%s\n"""%(partner,partner)                                   retStr+="""<option value="%s">%s\n"""%(partnerId,partnerTitle)
      except:       except:
          """nothing"""           """nothing"""
      return retStr       return retStr
     
     def getViewClassification(self):  #    def getViewClassification(self):
         if hasattr(self,'viewClassification'):  #        if hasattr(self,'viewClassification'):
             return self.viewClassification  #            return self.viewClassification
         else:  #        else:
             return ""  #            return ""
   
     def getTitle(self):  
     """title"""  
     try:  
         return self.title.encode('utf-8','ignore')   
     except:  
         self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error  
         return self.title.encode('utf-8','ignore')   
           
     def getLabel(self):  
     """title"""  
     try:  
         return self.label.encode('utf-8','ignore')   
     except:  
         self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error  
         return self.label.encode('utf-8','ignore')  
           
     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):
Line 1774  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 1789  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,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 1811  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):
         """OLD CreateJava"""  
         ret=javaScriptMain  
   
         dynamical="\n"  
         for ob in self.getGraphicCoords():  
         if ob[4][4] == "":    
             dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])  
         else:  
         dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])  
         dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])  
     ret+=javaHandler%dynamical  
         return ret  
   
     def createJSAreas(self):  
         """create area calls for JavaScript"""          """create area calls for JavaScript"""
         dynamical="\n"          areas = self.getAllMapAreas(mapColTypes=mapColTypes)
         for ob in self.getGraphicCoords():          return self.createJSAreas(areas)
         if ob[5] == "area":  
             dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob[1],ob[0])  
         else:  
             dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob[1],ob[0])  
         return dynamical  
   
     def createMapHead(self):  
         """create javascript include and script tags for head"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)  
         return pt()  
   
     def createMapImg(self):  
     """generate img-tag for map"""  
     bt = BrowserCheck(self)  
     tag = ""  
     src = self.REQUEST['URL1'] + "/overview"  
     if bt.isN4:  
         tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src  
     else:  
         tag += '<img id="overview" src="%s" />'%src  
     return tag  
           
     def createMapLink(self, ob, text=None):  
     """generate map link"""  
     bt = BrowserCheck(self)  
     id = ob[1]  
     link = ob[1]  
     if text == None:  
         text = ob[2]  
     tag = ""  
     if bt.isN4:  
         tag += '<ilayer id="a.%s"><a onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)  
         tag += ">" + text + "</a></ilayer>"  
     else:  
         tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)  
         if ob[3].contentType == 'text-popup':  
         tag += ' title="%s"'%ob[3].description  
         tag += ">" + text + "</a>"  
     return tag  
   
     def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil"):  
     """generate map link image, text and other stuff"""  
     id = ob[1]  
     link = ob[1]  
     vtype = ob[5]  
     ctype = ob[3].contentType  
     bt = BrowserCheck(self)  
     tag = ""  
   
     if bt.isN4:  
         tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)  
         if vtype == "view point":  
             rot = ob[4][4]  
         tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,arrowsrc,rot)  
         else:  
         tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)  
         if ctype == "text-popup":  
             desc = ob[3].description  
             tag += ' alt="%s"'%desc  
         tag += ' /></a>'  
         tag += '</layer>'  
     else:  
         tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)  
         if vtype == "view point":  
         rot = ob[4][4]  
         if bt.isIEWin and bt.versIE > 5:  
             tag += '<span id="i.%s" style="position:absolute; top:-100px; left:-100px; border-style:none; border-width=1px; filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\'%s&rot=%s\');"><img style="visibility:hidden" src="%s&rot=%s" /></span>'%(id,arrowsrc,rot,arrowsrc,rot)  
         else:  
             tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,arrowsrc,rot)  
         else:  
         if bt.isIEWin:  
             tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;background:url(area_img)"'%(id)  
         else:  
             tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)  
         if ctype == "text-popup":  
             desc = ob[3].description  
             tag += ' title="%s"'%desc  
         tag += '> </div>'  
         tag += '</a>'  
     return tag  
   
       emptyPartner=ECHO_partner("", "","", "", "", "", "", "", "")
           
     security.declarePublic('getCreditObject')      security.declarePublic('getCreditObject')
     def getCreditObject(self,name):      def getCreditObject(self,name):
Line 1936  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 1957  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,types=['title','label']):  
         """Rerender all Links"""  
     ret=""  
       
         if not obj:  
             obj = self  
               
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])  
   
         for entry in entries:  
         if entry[1].meta_type == 'ECHO_resource':  
             try:  
                 entry[1].ECHO_getResourceMD(template="no")  
                                 if "title" in types:  
                                     entry[1].generate_title()  
                                 if "label" in types:  
                                     entry[1].generate_label()  
                 ret+="OK:"+entry[0]+"-- "+entry[1].getTitle().decode('utf-8')+"-- "+entry[1].getTitle().decode('utf-8')+"<br>"  
             except:  
                 ret+="Error:"+entry[0]+"<br>"  
   
         else:  
            self.ECHO_rerenderLinksMD(entry[1])  
   
                                   
       def ECHO_rerenderLinksMDWarning(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/rerenderLinksWarning')
                   pt.content_type="text/html"
                   return pt()
                                   
         return ret+"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]    
             return x  
   
         except:  
   
             return []      security.declarePublic('ECHO_rerenderLinksMD')
       def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
           """Rerender all Links"""
           return ECHO_rerenderLinksMD(self,obj,types)
                   
     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):
   
         self.id = id          self.id = id
         """Festlegen der ID"""          """Festlegen der ID"""
Line 2019  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':'Change Labels','action':'changeLabels'},          {'label':'Change Labels','action':'changeLabels'},
         {'label':'Change Titles','action':'changeTitles'},          {'label':'Change Titles','action':'changeTitles'},
         {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMD'},          {'label':'Localize','action':'localizeObjects'},
         {'label':'Graphics','action':'ECHO_graphicEntry'},          {'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 Viewer Templates','action':'changeViewerTemplateSetsForm'},          {'label':'Change Image Viewer','action':'changeViewerForm'},
     {'label':'Reload Metadata','action':'reloadMetaDataFromStorage'},          {'label':'ImportCollection','action':'importCollection'},
     {'label':'ImportCollection','action':'updateCollection'},          {'label':'Change access rights',  'action':'changeAccessRightsCollectionForm'},
     {'label':'Copy MD for indexing and search','action':'copySearchFields'},  
         )          )
   
     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 2073  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 2090  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,location=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.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')
                           
       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')  
           
       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 2158  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 = BrowserCheck(self)          bt = browserType(self)
     if bt.isIE or bt.isN4:          if bt['isIE'] or bt['isN4']:
         return sendFile(self, 'images/red.gif', 'image/gif')          return sendFile(self, 'images/red.gif', 'image/gif')
     else:      else:
         return sendFile(self, 'images/reda.png', 'image/png')          return sendFile(self, 'images/reda.png', 'image/png')
Line 2173  class ECHO_collection(Folder, Persistent Line 1584  class ECHO_collection(Folder, Persistent
         return sendFile(self, 'js/hl_lib.js', 'text/plain')          return sendFile(self, 'js/hl_lib.js', 'text/plain')
   
     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"""
         return sendFile(self, 'js/js_lib.js', 'text/plain')          return sendFile(self, 'js/baselib.js', 'text/plain')
   
     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)  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 2235  class ECHO_group(ECHO_collection): Line 1683  class ECHO_group(ECHO_collection):
   
     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')      security.declareProtected('View','index_html')
   
     def getRDF(self):  
           def getRDF(self,urn=None):
         """rdf of the collection"""          """rdf of the collection"""
         contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])          contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
   
         ret=getRDFDescription(self,self.absolute_url())              ret=getRDFDescription(self,self.absolute_url(),urn=urn)
   
                   
               if not urn:
         urn="urn:"+re.sub('/',':',self.absolute_url())                      urn=self.absolute_url()
         li="""<RDF:li resource="%s" />\n"""              li="""<rdf:li rdf:resource="%s" />\n"""
                   
                   
         for content in contents:          for content in contents:
             ret+=content[1].getRDF()+"\n"                      ret+=self.unicodify(content[1].getRDF())+"\n"
                           
         ret+="""<RDF:Seq about="%s">\n"""%urn              ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
         for content in contents:          for content in contents:
             nurn="urn:"+re.sub('/',':',content[1].absolute_url())                      nurn=content[1].absolute_url()
             ret+=li%nurn              ret+=li%nurn
         return ret+"</RDF:Seq>"              return ret+"</rdf:Seq>"
                   
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
Line 2280  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 2296  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 2308  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 2331  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 2450  class ECHO_userFolder(UserFolder): Line 1893  class ECHO_userFolder(UserFolder):
             return 1              return 1
         return 0          return 0
   
 Globals.default__class_init__(ECHO_userFolder)  # ROC: problem with 2.12
   #Globals.default__class_init__(ECHO_userFolder)
   
   
   
Line 2471  def manage_addECHO_userFolderForm(self): Line 1915  def manage_addECHO_userFolderForm(self):
     """add a user folder form"""      """add a user folder form"""
     return manage_addECHO_userFolder(self)      return manage_addECHO_userFolder(self)
   
 class ECHO_root(Folder,Persistent,Implicit):  
     """ECHO Root Folder"""  
   
     security=ClassSecurityInfo()  
       
     meta_type="ECHO_root"  
           
     def showRDF(self):  
         """showrdf"""  
             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
         ret="""<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"  xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""  
         ret+=self.getRDF()+"\n"  
         ret+="""</RDF:RDF>"""  
             return ret  
   
     def getRDF(self):  
         """rdf of the collection"""  
         contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])  
   
         about="""<RDF:Description about="%s">"""  def createNode(self,descrs,node):
         name="""<ECHONAVIGATION:name>%s</ECHONAVIGATION:name>"""          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":
                   
         urn="urn:"+re.sub('/',':',self.absolute_url())  
   
         about2=about%urn  
         name2=name%self.getId()  
           
   
         ret=about2+"\n"+name2+"\n"+"</RDF:Description>"  
   
         li="""<RDF:li resource="%s" />\n"""  
   
           
         for content in contents:  
             ret+=content[1].getRDF()+"\n"  
               
         ret+="""<RDF:Seq about="%s">\n"""%urn  
         for content in contents:  
             nurn="urn:"+re.sub('/',':',content[1].absolute_url())  
             ret+=li%nurn  
         return ret+"</RDF:Seq>"  
           
   
     def showContent(self,path):  
         """return content/html"""  
           
         return urllib.urlopen(path+"/content_html").read()  
       
     def getImageViewers(self):  
         """images"""  
         viewers=self.ZopeFind(self.standardImageViewer,obj_metatypes=['OSAS_ViewerObject'])  
         return viewers  
       
   
     def getBibTag(self,tag,content):  
         """get field tag für index-meta-generation"""  
         if not content or content=="":  
             return ""  
         ret="<%s>"%tag  
         #ret+=urllib.quote(content)  
         ret+=content  
   
         ret+="</%s>"%tag  
         return ret  
   
     def getValueFromClass(self,field,found):  
         """retattribute falss existing"""  
         try:          try:
                           manage_addECHO_collection(self,id,name,name,"","","","","")
                           
             return getattr(found,field).decode('ascii','ignore')  
         except:          except:
             return ""                          self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
           
     def getImageTag(self):                  self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
         """needed by main_template"""  
         return ""  
     secondaryLink="" #needed by main_template  
     secondaryLinkTitle="" #needed by main_template  
           
     def getBgcolour(self):                  return type,getattr(self,id),urn
     """hack"""  
     return "#dddddd"  
   
     def contentTypeSelector_HTML(self,selected=None):          if type=="CDLI_item":
         """give type selector"""  
         if not selected:  
             retStr="<option selected>\n"  
         else:  
             retStr="<option>\n"  
               
         try: # erste version contentTypes exists  
             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):  
                 if selected and (contentType[0]==selected):  
                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])  
                 else:                  
                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])  
         except:  
         try:          try:
             for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):                          manage_addECHO_resource(self,id,name,name,"","",urn,"","")
                 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)
                   self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
                                   
     return retStr  
   
     def renderingTypeSelector_HTML(self,selected=None):          return "XX"
          """give type selector"""  
      if not selected:  
          retStr="<option selected>\n"  
      else:  
          retStr="<option>\n"  
            
      try: # erste version renderingTypes exists  
          for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):  
              if selected and (renderingType[0]==selected):  
                  retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])  
              else:                  
                  retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])  
      except:  
          """nothing"""  
      return retStr  
   
     def renderingTypeSelector_HTML(self,selected=None):  
          """give type selector"""  
      if not selected:  
          retStr="<option selected>\n"  
      else:  
          retStr="<option>\n"  
            
      try: # erste version renderingTypes exists  
          for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):  
              if selected and (renderingType[0]==selected):  
                  retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])  
              else:                  
                  retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])  
      except:  
          """nothing"""  
      return retStr  
   
   
     def copyrightTypeSelector_HTML(self,selected=None,first=None):  
          """give type selector"""  
   
      if not first:  
          if not selected:  
              retStr="<option selected>\n"  
          else:  
              retStr="<option>\n"  
      else:  
          if not selected:  
              retStr="""<option selected value="%s">%s\n"""%first  
          else:  
              retStr="""<option value="%s">%s\n"""%first  
   
   class ECHO_copyrightType(Folder,ECHO_basis):
           """copyright typ"""
             
      try: # erste version copyrightTypes exists          meta_type="ECHO_copyrightType"
          for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):  
              if selected and (copyrightType[0]==selected):  
                  retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
              else:                  
                  retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
      except:  
          """nothing"""  
      return retStr  
   
     def partnerSelector_HTML(self,selected=None):          def __init__(self,id,title,label,url):
          """give type selector"""                  """init"""
      if not selected:                  self.id=id
          retStr="<option selected>\n"                  self.title=title
      else:                  self.label=label
          retStr="<option>\n"                  self.url=url
                     
      try: # erste version copyrightTypes exists          manage_options = Folder.manage_options+(
          for copyrightType in self.ZopeFind(self.partners,obj_metatypes=["ECHO_partner"]):          {'label':'Main Config','action':'ECHO_copyrightType_config_mainForm'},
              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  
     
     mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version über echoroot??          def ECHO_copyrightType_config_mainForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_copyrightType')
                   pt.content_type="text/html"
                   return pt()
   
     def mediaTypeSelector_HTML(self,selected=None):          def ECHO_copyrightType_config_main(self,title,label,url,RESPONSE=None):
          """give type selector"""                  """change"""
      if not selected:                  self.title=title
          retStr="<option selected>\n"                  self.label=label
      else:                  self.url=url
          retStr="<option>\n"  
             
      try: # erste version mediatypesTypes exists                  if RESPONSE is not None:
          for mediaType in self.mediaTypes:                          RESPONSE.redirect('manage_main')
              if selected and (mediaType in selected):  
                  retStr+="""<option selected value="%s">%s\n"""%(mediaType,mediaType)  
              else:                  
                  retStr+="""<option value="%s">%s\n"""%(mediaType,mediaType)  
      except:  
          """nothing"""  
      return retStr  
   
   def manage_addECHO_copyrightTypeForm(self):
           """Form for adding a ressource"""
           pt=zptFile(self, 'zpt/AddECHO_copyrightTypeForm.zpt')
           return pt()
                           
     def patchContentType(self,obj=None):  
         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""  
           
   def manage_addECHO_copyrightType(self,id,title,label,url,RESPONSE=None):
       """addaresource"""
   
         if not obj:      newObj=ECHO_copyrightType(id,title,label,url)
             obj = self  
                           
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])      self._setObject(id,newObj)
   
         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':  
                     entry[1].patchContentType(entry[1])      
   
                                   
         return "changed all contenttypes in: "+self.title  
   
   class ECHO_linkList(ZopePageTemplate,ECHO_basis):
       """LinkList Objekt"""
       meta_type="ECHO_linkList"
   
     def patchViewClassification(self,obj=None):      _default_content_fn = os.path.join(package_home(globals()), 'html/ECHO_pageTemplateDefault.html')
         """setze viewClassification heuristisch"""  
   
     def checkIfArrow(obj):      manage_options = ZopePageTemplate.manage_options+(
         if hasattr(obj,'coords'):          {'label':'Main Config','action':'changeECHO_linkListWeightForm'},
             for coordtemp in obj.coords:          )
   
                 if (len(coordtemp)>4) and not (coordtemp[4]==''):      def content_html(self):
                     return 4          """content_html"""
             return None          return ECHO_basis.content_html(self,'pageTemplate')
         return None  
           
         if not obj:      def changeECHO_linkListWeightForm(self):
             obj = self          """change"""
           pt=zptFile(self, 'zpt/ChangeECHO_linkListTemplate.zpt')
           return pt()
                           
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])      def changeECHO_linkListWeight(self,contentType,label,RESPONSE=None):
           """change"""
           self.contentType=contentType
           self.label=label
   
         for entry in entries:          if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
                   
         if checkIfArrow(entry[1]):      def getLabel(self):
             setattr(entry[1],'viewClassification','view point')          if hasattr(self,'label'):
               return self.label.encode('utf-8')
         else:          else:
             setattr(entry[1],'viewClassification','area')              return 0
   
                 #entry[1].contentType == entry[1].content_type  
   
                 if entry[1].meta_type in ['ECHO_collection','ECHO_group']:  
                     entry[1].patchViewClassification(entry[1])      
   
                   
         return "changed all contenttypes in: "+self.title  
   
     def ECHO_newViewerLink(self,obj=None):  
         """change links (:86 faellt weg)"""  
   
         if not obj:  
             obj = self  
               
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])  
   
         for entry in entries:  
                   
                 if entry[1].meta_type == 'ECHO_resource':  
                       
                     entry[1].link=re.sub('\:86','',entry[1].link)  
   
       def getcontentType(self):
           """get contentType"""
           if hasattr(self,'contentType'):
               return normalizeCt(self.contentType)
                 else:                  else:
               return 0
                                           
                     entry[1].ECHO_newViewerLink(entry[1])      def __init__(self, id, label, title=None, text=None, contentType=None):
                            self.id = str(id)
         return "Rerenderd all links to resources in: "+self.title  
   
     def __init__(self,id,title):  
         """init"""  
         self.id = id  
         self.title=title          self.title=title
            self.label=label
     def deleteSpace(self,str):           self.ZBindings_edit(self._default_bindings)
         """delete space at the end of a line"""           if text is None:
         if str[len(str)-1]==" ":               text = ''
             return str[0:len(str)-1]           if content_type is None:
         else:               content_type = self.content_type
             return str           self.pt_edit(text, contentType)
                   
           
   
     # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt  
   
     def formatAscii(self,str,url=None):  def manage_addECHO_linkListForm(self):
         """ersetze ascii umbrueche durch <br>"""      """Form for adding"""
         #url=None      pt=zptFile(self, 'zpt/AddECHO_linkListTemplate.zpt')
         if url:      return pt()
                           
             retStr=""  
             words=str.split("\n")  
                           
             for word in words:  def manage_addECHO_linkList(self, id, label,contentType=0,title=None, text=None,
                 strUrl=url%word                             REQUEST=None, submit=None):
       """Add a LinkList with optional file content."""
   
                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)      id = str(id)
             str=retStr      if REQUEST is None:
         if str:          self._setObject(id, ECHO_linkList(id, label, text))
             return re.sub(r"[\n]","<br/>",str)          ob = getattr(self, id)
           setattr(ob,'contentType',contentType)
           if title:
               ob.pt_setTitle(title)
           return ob
         else:          else:
             return ""          file = REQUEST.form.get('file')
                   headers = getattr(file, 'headers', None) 
     def link2html(self,str):          if (headers is None) or (not file.filename):
         """link2html fuer VLP muss hier noch raus"""              zpt = ECHO_linkList(id, file)
         if str:          else:
               zpt = ECHO_linkList(id, label,'', file, headers.get('contentType'))
             str=re.sub("\&","&amp;",str)  
             dom=xml.dom.minidom.parseString("<?xml version='1.0' encoding='utf-8'?><txt>"+str+"</txt>")  
             links=dom.getElementsByTagName("link")  
               
   
             for link in links:  
                 link.tagName="a"  
                 ref=link.getAttribute("ref")  
                 if self.checkRef(ref):  
                     link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)  
   
             newxml=dom.toxml('utf-8')  
         match=re.sub(r'<\?xml version=\"1.0\" encoding=\"utf-8\"\?>\n<txt>','',newxml)  
         match=re.sub(r'</txt>','',match)  
           
         return match  
                  
         return ""  
   
     def xml2html(self,str):  
         """link2html fuer VLP muss hier noch raus"""  
         if str:  
   
             str=re.sub("\&","&amp;",str)  
             dom=xml.dom.minidom.parseString(str)  
             links=dom.getElementsByTagName("link")  
               
   
             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')  
         return ""  
   
     def checkRef(self,ref):  
         dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}  
         res=None  
         for db in dbs.keys():  
   
             res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))  
         return res  
                                       
     #Ende Methode fuer vlp  
   
     def PgQuoteString(self,string):  
         """Quote string"""  
   
         return libpq.PgQuoteString(string)  
           
     def getPartners(self):  
         """Get list of Partners. Presently only from a subfolder partners"""  
                       
         return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]  
                   
                   
                      
   
       
     def getPartnersXML(self):  
         """partner liste als xml"""   
         partners=self.getPartners()  
         ret="""<?xml version="1.0" encoding="utf-8" ?>  
     <partners>"""  
           
     for partner in partners:  
             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),unicode(partner.title,'utf-8','replace'))  
   
         return ret+"\n</partners>"  
           
     def getCollectionTree(self):          self._setObject(id, zpt)
         """get the collection tree (list of triples (parent,child, depth)"""          ob = getattr(self, id)
           if title:
               ob.pt_setTitle(title)
   
         def getCollection(object,depth=0):  
             depth+=1  
             collections=[]  
             for entry in object.__dict__.keys():  
                 element=getattr(object,entry)  
                 try:                  try:
                     if element.meta_type=="ECHO_collection":              u = self.DestinationURL()
                         collections.append((object,element,depth))          except AttributeError:
                         collections+=getCollection(element,depth)              u = REQUEST['URL1']
                 except:  
                     """nothing"""  
             return collections  
           
   
         return getCollection(self)          if submit == " Add and Edit ":
               u = "%s/%s" % (u, urllib.quote(id))
           REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
           
     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  
   
     def getResourcesHTML(self,viewerType=None,filter=None):  class ECHO_support(Folder,ECHO_basis):
         """gebe all ressourcen aus"""          """gefoerdert durch"""
           meta_type="ECHO_support"
   
         def sortHTML(x,y):  
             return cmp(x[1].title,y[1].title)  
                   
         ret="""<html><body><h2>Resources in ECHO</h3>"""  
                   
         resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)          def __init__(self,id,institutions=None):
         ret+="""<h3>Found %i resources</h3>"""%len(resources)                  """init"""
         resources.sort(sortHTML)                  self.id=id
         for resource in resources:                  self.title=''
             echo_url=resource[1].absolute_url()                  self.institutions=toList(institutions)
                           
             if hasattr(resource[1],'title'):          def getSupporter(self):
                 title=resource[1].title                  """return institutions"""
                   if self.institutions:
                           return self.institutions
             else:              else:
                 title="None"                          return []
             if filter:  
                 if re.search(filter,title):  
                     ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)  
             else:  
                 ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)  
   
         ret +="""\n</body></html>"""          manage_options = Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_support_configForm'},
                   )
                   
         #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")          def ECHO_support_configForm(self):
         #self.REQUEST.RESPONSE.write(ret)                  """change form"""
             return ret                  pt=zptFile(self, 'zpt/ChangeECHO_support')
                   pt.content_type="text/html"
                   return pt()
           
     def getResourcesXML(self,viewerType=None,filter=None):          def ECHO_support_config(self,institutions=None,RESPONSE=None):
         """gebe all ressourcen aus"""                  """change"""
         ret="""<?xml version="1.0" ?>                  self.institutions=toList(institutions)
                  <index>"""  
         for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):  
   
             echo_url=resource[1].absolute_url()                  if RESPONSE is not None:
             if hasattr(resource[1],'link'):                          RESPONSE.redirect('manage_main')
                 viewer_url=resource[1].link  
             else:  
                 viewer_url="NO URL"  
             if filter:  
                 if re.search(filter,viewer_url):  
                     ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
             else:  
                 ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
         ret +="""\n</index>"""  
                   
         self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")  
         self.REQUEST.RESPONSE.write(ret)  
   
     def getFullTextsXML(self,viewerType=None,filter=None):  def manage_addECHO_supportForm(self):
         """gebe all ressourcen aus"""      """Form for adding"""
         ret="""<?xml version="1.0" ?>      pt=zptFile(self, 'zpt/AddECHO_support.zpt')
                  <index>"""      return pt()
         for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):  
   
             echo_url=resource[1].absolute_url()  def manage_addECHO_support(self, id,institutions=None,RESPONSE=None):
             if resource[1].getFullTextXML(noredirect="yes"):          """add the copyright"""
                 if hasattr(resource[1],'link'):  
                     viewer_url=echo_url+"/getFullTextXML"  
                 else:  
                     viewer_url="NO URL"  
                 if filter:  
                     if re.search(filter,viewer_url):  
                         ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
                 else:  
                     ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
         ret +="""\n</index>"""  
                   
           meta_type="ECHO_support"
                   
         self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")  
         self.REQUEST.RESPONSE.write(ret)  
   
           self._setObject(id, ECHO_support(id,institutions))
   
     def getMetaDatasXML(self,viewerType=None,filter=None):          if RESPONSE is not None:
         """gebe all ressourcen aus"""                  RESPONSE.redirect('manage_main')
         ret="""<?xml version="1.0" ?>  
                  <index>"""  
         for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):  
   
             echo_url=resource[1].absolute_url()  # ECHO - owner of original
   class ECHO_ownerOriginal(Folder,ECHO_basis):
           """besitzer des originals"""
           meta_type="ECHO_ownerOriginal"
           security=ClassSecurityInfo()
                           
             if hasattr(resource[1],'link'):  
                 meta_url=echo_url+"/getMetaDataXML"  
             else:  
                 meta_url="NO_URL"  
                                   
             if filter and not re.search(filter,viewer_url):          def __init__(self,id,institutions=None):
                 continue                  """init"""
                   self.id=id
                   self.title=''
                   self.institutions=toList(institutions)
   
             ret+="""\n<resource resourceLink="%s" metaLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(meta_url,safe='/:?'))          security.declarePublic('getOwner')
           def getOwner(self):
                   """return institutions"""
                   if self.institutions:
                           return self.institutions
                   else:
                           return []
                                   
         ret +="""\n</index>"""          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()
                   
         self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")          def ECHO_ownerOriginal_config(self,institutions=None,RESPONSE=None):
         self.REQUEST.RESPONSE.write(ret)                  """change"""
                   self.institutions=toList(institutions)
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
                   
     def findPartners(self):   
         """find all partners in partners"""  
         par=self.ZopeFind(self.partners, obj_metatypes='ECHO_partner')  
         return par  
                   
     def getPartnerFromID(self):  def manage_addECHO_ownerOriginalForm(self):
         """find partner form ID return object"""      """Form for adding"""
         pa=self.REQUEST['partner']      pt=zptFile(self, 'zpt/AddECHO_ownerOriginal.zpt')
         par=self.ZopeFind(self.partners, obj_ids=[pa])      return pt()
         return par  
                   
     def getPartnerFromIDParameter(self, id):  def manage_addECHO_ownerOriginal(self, id,institutions=None,RESPONSE=None):
         """ find partners from ID"""          """add the copyright"""
         par=self.ZopeFind(self.partners, obj_ids=[id])  
         return par  
   
           meta_type="ECHO_ownerOriginal"
   
                   
 def manage_addECHO_root(self,id,title,RESPONSE=None):          self._setObject(id, ECHO_ownerOriginal(id,institutions))
     """Add an ECHO_root"""  
     self._setObject(id,ECHO_root(id,title))  
           
     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"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)  
         return pt()  
   
 class ECHO_copyrightType(Folder):  # ECHO - digitized copy by
     """copyright typ"""  class ECHO_digiCopyBy(Folder,ECHO_basis):
           """besitzer des originals"""
           meta_type="ECHO_digiCopyBy"
           security=ClassSecurityInfo()
   
     meta_type="ECHO_copyrightType"  
           
     def __init__(self,id,title,label,url):          def __init__(self,id,institutions=None):
         """init"""          """init"""
         self.id=id          self.id=id
         self.title=title                  self.title=''
         self.label=label                  self.institutions=toList(institutions)
         self.url=url  
           security.declarePublic('getDigiCopyBy')
           def getDigiCopyBy(self):
                   """return institutions"""
                   if self.institutions:
                           return self.institutions
                   else:
                           return []
   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Main Config','action':'ECHO_copyrightType_config_mainForm'},                  {'label':'Main Config','action':'ECHO_digiCopyBy_configForm'},
     )      )
   
     def ECHO_copyrightType_config_mainForm(self):          def ECHO_digiCopyBy_configForm(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_copyrightType').__of__(self)                  pt=zptFile(self, 'zpt/ChangeECHO_digiCopyBy')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
     def ECHO_copyrightType_config_main(self,title,label,url,RESPONSE=None):          def ECHO_digiCopyBy_config(self,institutions=None,RESPONSE=None):
         """change"""          """change"""
         self.title=title                  self.institutions=toList(institutions)
         self.label=label  
         self.url=url  
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
 def manage_addECHO_copyrightTypeForm(self):                  
         """Form for adding a ressource"""  def manage_addECHO_digiCopyByForm(self):
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_copyrightTypeForm.zpt').__of__(self)      """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_digiCopyBy.zpt')
         return pt()          return pt()
   
   def manage_addECHO_digiCopyBy(self, id,institutions=None,RESPONSE=None):
           """add the copyright"""
   
 def manage_addECHO_copyrightType(self,id,title,label,url,RESPONSE=None):          meta_type="ECHO_digiCopyBy"
     """addaresource"""  
   
     newObj=ECHO_copyrightType(id,title,label,url)  
   
     self._setObject(id,newObj)          self._setObject(id, ECHO_digiCopyBy(id,institutions))
   
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
     
   # --------------------------------------------------------------------------------  
   
   class ECHO_institution(Image,Persistent,ECHO_basis):
       """ECHO Institution"""
     
 class ECHO_partner(Image,Persistent):      meta_type="ECHO_institution"
     """ECHO Partner"""  
   
     meta_type="ECHO_partner"      def __init__(self, id, title,url, file, person, email, country, content_type='', precondition=''):
   
     def __init__(self, id, title,url, file, copyrightType, person, email, country, color, 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.person=person
         self.email=email          self.email=email
         self.country=country          self.country=country
         self.color=color  
         self.precondition=precondition          self.precondition=precondition
         self.copyrightType=copyrightType  
         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,copyrightType,person, email, country, color, 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.person=person
         self.email=email          self.email=email
         self.country=country          self.country=country
         self.color=color  
         self.copyrightType=copyrightType  
         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, url, person, email, country, color, file=None, copyrightType='', 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 3132  def manage_addECHO_partner(self, id, url Line 2328  def manage_addECHO_partner(self, id, url
     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,'',copyrightType, person, email, country, color, 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 3147  def manage_addECHO_partner(self, id, url Line 2343  def manage_addECHO_partner(self, id, url
         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.142  
changed lines
  Added in v.1.310.2.12

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