[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.89 and 1.241

version 1.89, 2004/05/24 19:04:09 version 1.241, 2005/10/26 16:58:17
Line 9  class ECHO_externalLink contains informa Line 9  class ECHO_externalLink contains informa
   
   
 """  """
   try:
           from reportlab.pdfgen import canvas
           from reportlab.lib.pagesizes import A4
   except:
           print "PDF generation will not work"
        
   
 import string  import string
   import tempfile
 import re  import re
 import os  import os
 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 28  from Products.PageTemplates.PageTemplate Line 37  from Products.PageTemplates.PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Globals import Persistent, package_home  from Globals import Persistent, package_home
 from Acquisition import Implicit  from Acquisition import Implicit
 from ECHO_helpers import displayTypes  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   
   import urllib
   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 zLOG
   
 try:  try:
     from psycopg import libpq      from psycopg import libpq
Line 43  import xml.dom.minidom Line 63  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 *
   from ECHO_language import *
   from ECHO_movie import *
   import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
   
 #List of different types for the graphical linking viewer  
 viewClassificationListMaster=['view point','area']  
   
 def checkDiffs(self,metadict):  
         """check differences"""  
   
         def NoneToEmpty(obj):  def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs=""):
             if obj:  
                 return obj  
             else:  
                 return ""  
                   
         diffs={}          """Allegemeine Informationen zu einer ECHO Collection"""
         tags=self.findTagsFromMapping(self.contentType)  
         for field in tags[1]:  
             try:  
                 if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):  
                     diffs[self.getFieldTag(tags,field)]=1  
                 else:  
                     print "DIFF",field,self.getFieldValue(self.getFieldTag(tags,field)),metadict[self.getFieldTag(tags,field)]  
                     diffs[self.getFieldTag(tags,field)]=0  
             except:  
                 diffs[self.getFieldTag(tags,field)]=0  
                 print "EX",field  
         return diffs  
           
 def content_html(self,type):          self.label = label
         """template fuer content"""          self.title=title
         #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])          self.description=description
         #          self.contentType=contentType
         #if templates:          self.responsible=responsible
         #    return templates[0][1]()          self.credits=toList(credits)
           self.weight=weight
   
         try:  class ECHO_locale(ZopePageTemplate):
             obj=getattr(self,type+"_template")          """localisierung"""
             return obj()  
         except:          meta_type="ECHO_locale"
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)  
           def __init__(self,id,lang,title,label,text=None,content_type=None):
                   self.lang=lang
                   self.title=title
                   self.label=label
                   if text:
                           self.pt_edit(text, content_type)
                   self.id=id
   
           manage_options = ZopePageTemplate.manage_options+(
                   {'label':'Main Config','action':'change_ECHO_localeForm'},
                   )
   
           def change_ECHO_localeForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_localeForm.zpt')
                   return pt()
           
           def change_ECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
                   """change echo locale"""
                   self.lang=lang
                   self.title=title
                   self.label=label
                   if not text is None:
                           self.pt_edit(text, content_type)
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
                   
   def manage_addECHO_localeForm(self):
            """Form for adding"""
            pt=zptFile(self, 'zpt/AddECHO_localeForm.zpt')
            return pt()
   
   def manage_addECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
           """add echo locale"""
   
           id="locale_"+lang
           
           self._setObject(id, ECHO_locale(id,lang,title,label,text,content_type))
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
   
   
   class ECHO_copyright(Folder,ECHO_basis):
           """Copyright informationen"""
           meta_type="ECHO_copyright"
           
           
           
           def __init__(self,id,title,copyrights):
                   """init"""
                   self.title=title
                   self.id=id
                   self.copyrights=copyrights[0:]
   
           def getCopyrights(self):
                   """return coyprights"""
                   return self.copyrights
                   
           manage_options = Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_copyright_configForm'},
                   )
   
   
           def ECHO_copyright_configForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_copyright')
             pt.content_type="text/html"              pt.content_type="text/html"
             return pt()              return pt()
           
 def toList(field):          def ECHO_copyright_config(self,title,RESPONSE=None):
     """Einzelfeld in Liste umwandeln"""                  """change"""
     if type(field)==StringType:                  self.title=title
         return [field]                  self.copyrights=[]
                   self.copyrights=getCopyrightsFromForm(self,self.REQUEST.form)[0:]
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
                   
   def manage_addECHO_copyrightForm(self):
       """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_copyright.zpt')
       return pt()
   
   def manage_addECHO_copyright(self, id,title,RESPONSE=None):
           """add the copyright"""
   
           meta_type="ECHO_copyright"
           
           #first generate copyrights as list of tripels (mediaType,partner,copyrightType)
           
                   
   
           self._setObject(id, ECHO_copyright(id, title,getCopyrightsFromForm(self,self.REQUEST.form)))
   
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
           
   class ECHO_layoutTemplate(ZopePageTemplate,ECHO_basis):
       """Create a layout Template for different purposes"""
   
       meta_type="ECHO_layoutTemplate"
   
       def __init__(self, id, text=None, content_type=None,EchoType=None):
           self.id = str(id)
   
           self.ZBindings_edit(self._default_bindings)
           if text is None:
               self._default_content_fn = os.path.join(package_home(globals()),'zpt','ECHO_%s_template_standard.zpt'%EchoType)
               text = open(self._default_content_fn).read()
           self.pt_edit(text, content_type)
   
   
   def manage_addECHO_layoutTemplateForm(self):
       """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_layoutTemplate.zpt')
       return pt()
   
   
   def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
       "Add a Page Template with optional file content."
       if type(EchoType)==StringType:
           EchoTypes=[EchoType]
     else:      else:
         return field          EchoTypes=EchoType
           
       for singleType in EchoTypes:
           
 def getText(nodelist):          id = str(singleType)+"_template"
           if REQUEST is None:
               self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))
               ob = getattr(self, id)
   
     rc = ""              if title:
     for node in nodelist:                  ob.pt_setTitle(title)
         if node.nodeType == node.TEXT_NODE:              return ob
            rc = rc + node.data          else:
     return rc              file = REQUEST.form.get('file')
               headers = getattr(file, 'headers', None)
               if headers is None or not file.filename:
 def sendFile(self, filename, type):                  zpt = ECHO_layoutTemplate(id,EchoType=singleType)
     """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:      else:
         object = None                  zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))
   
               self._setObject(id, zpt)
               ob = getattr(self, id)
               if title:
                   ob.pt_setTitle(title)
   
               try:
                   u = self.DestinationURL()
               except AttributeError:
                   u = REQUEST['URL1']
   
               
       REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
   class ECHO_fullText(ZopePageTemplate,ECHO_basis,ECHO_language):
           """echo fulltext in xml"""
   
           meta_type="ECHO_fullText"
   
           
           def getPage(self,nr='1'):
                   """get page n"""
                   #return self().encode('latin-1','ignore')
                   dom=xml.dom.minidom.parseString(self().encode('utf-8','ignore'))
                   pages=dom.getElementsByTagName('page')
                   
                   return pages[int(nr)-1].toxml()
           
   # Product registration and Add support
   manage_addECHO_fullTextForm = PageTemplateFile(
       'zpt/AddECHO_fullText.zpt', globals())
   
   def manage_addECHO_fullText(self, id, title=None, text=None,
                              REQUEST=None, submit=None):
       "Add a Page Template with optional file content."
   
       id = str(id)
       if REQUEST is None:
           self._setObject(id, ECHO_fullText(id, text))
           ob = getattr(self, id)
           if title:
               ob.pt_setTitle(title)
           return ob
       else:
           file = REQUEST.form.get('file')
           headers = getattr(file, 'headers', None)
           if headers is None or not file.filename:
               zpt = ECHO_fullText(id)
           else:
               zpt = ECHO_fullText(id, file, headers.get('content_type'))
   
           self._setObject(id, zpt)
   
           try:
               u = self.DestinationURL()
           except AttributeError:
               u = REQUEST['URL1']
   
           if submit == " Add and Edit ":
               u = "%s/%s" % (u, urllib.quote(id))
           REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
   
   class ECHO_resource(CatalogAware,Folder,Persistent,ECHO_basis):
       """ECHO Ressource"""
       security=ClassSecurityInfo()
       meta_type='ECHO_resource'
       default_catalog='resourceCatalog'
       
   #    viewClassificationList=viewClassificationListMaster
   
       def PrincipiaSearchSource(self):
              """Return cataloguable key for ourselves."""
              return str(self)
   
       getSubCols = ECHO_helpers.getSubCols
   
       def reindex(self):
           """generate fields for indexing and reindex"""
           import urlparse
           #TODO: korrigieren des metalink pfades konfigurierbar machen
           splitted= [x for x in urlparse.urlparse(self.metalink)]
           splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]
           
           if splitted[0]=="http":
               self.metalink=urlparse.urlunparse(splitted)
           
   
           self.fullTextUrl=self.getFullTextXML(noredirect="yes")
           
           #TODO: korrigieren relative url to absoluter url volltexten, konfigurierbar?
           splitted= [x for x in urlparse.urlparse(self.fullTextUrl)]
           if splitted[0]=="":
               splitted[0]="http"
               splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]
               
               self.fullTextUrl=urlparse.urlunparse(splitted)
               
           self.imagePath=self.getImagePath()
           
           self.reindex_object()
     
     
       security.declareProtected('View','createPDF')
       def createPDF(self,RESPONSE=None,local=None,dpi=150):
               """erzeuge pdf file"""
               pages=1
               dpi=float(dpi)
               imagePath=self.getImagePath().replace("/mpiwg/online","")
               
               
               image="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn="+imagePath+"&dw=%i&dh=%i&pn=%i"
               xmlInfo="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/dlInfo-xml.jsp?fn="+imagePath
   
               dom=xml.dom.minidom.parse(urllib.urlopen(xmlInfo))
               for parameter in dom.getElementsByTagName('parameter'):
                       if parameter.getAttribute('name')=="pt":
                               pages=int(parameter.getAttribute('value'))
         break          break
     if object:  
     # if the object exists then send it  
     return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)  
     else:  
     # send a local file with the given content-type  
     fn = os.path.join(package_home(globals()), filename)  
     self.REQUEST.RESPONSE.setHeader("Content-Type", type)  
     self.REQUEST.RESPONSE.write(file(fn).read())  
     return  
   
 class BrowserCheck:  
     """check the browsers request to find out the browser type"""  
           
     def __init__(self, zope):              tempdir="/tmp/archivesImageServer"
     self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")              if not os.path.exists(tempdir):
     self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and (string.find(self.ua, 'MSIE') < 0)                      os.mkdir(tempdir) 
     self.isIE = string.find(self.ua, 'MSIE') > -1    
     self.nav = self.ua[string.find(self.ua, '('):]              tmpPath=tempfile.mkdtemp(dir=tempdir)
     ie = string.split(self.nav, "; ")[1]              
     if string.find(ie, "MSIE") > -1:  
         self.versIE = string.split(ie, " ")[1]              tmpZip=tempfile.mktemp(dir=tempdir)
     self.isMac = string.find(self.ua, 'Macintosh') > -1  
     self.isWin = string.find(self.ua, 'Windows') > -1              tmpFn=os.path.split(tmpZip)[1]
     self.isIEWin = self.isIE and self.isWin  
     self.isIEMac = self.isIE and self.isMac  
       
   
               if RESPONSE:
                       RESPONSE.setHeader("Content-Type","text/html")
                       RESPONSE.write("<h1>I am creating  the pdf</h1>")
                       txt="<h3>1. step: getting the images( %i pages)</h3>"%pages
                       RESPONSE.write(txt)
   
               c=canvas.Canvas(tmpZip)
               for i in range(1,pages+1):
                       if RESPONSE:
                               RESPONSE.write(str("<p>Get Page: %i<br>\n"%i))
                       faktor=dpi/72.0
                       
                       fn=tmpPath+"/%i"%i
   
                       width,height=A4
                       #print image%(width*faktor,height*faktor,i)
                       url=urllib.urlopen(image%(width*faktor,height*faktor,i)).read()
                       fh=file(fn,"w")
                       fh.write(url)
                       fh.close()
   
       
   
                       c.drawImage(fn,0,0,width=width,height=height)
                       c.showPage()
               c.save()
               if RESPONSE:
                       RESPONSE.write("<p>finished<br>\n")
   
 def writeMetadata(url,metadict):              if RESPONSE:
     """Einlesen der Metadaten und und erstellen des geaenderten XML file"""                      len=os.stat(tmpZip)[6]
                       downloadUrl=self.absolute_url()+"/downloadPDF"
                       RESPONSE.write("""<h1><a href="downloadPDF?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))
                       RESPONSE.write("""<p>The file will be stored for a while, you can download it later, the URL is:</p>
                       <p><a href="downloadPDF?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn))
                       RESPONSE.close()
   
   
       def downloadPDF(self,fn):
               """download prepared set"""
               filename="/tmp/archivesImageServer/"+fn
               namePDF=self.getId()+".pdf"
               self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%namePDF)
               self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
               len=os.stat(filename)[6]
               self.REQUEST.RESPONSE.setHeader("Content-Length",len)
               images=file(filename).read()
               self.REQUEST.RESPONSE.write(images)
               self.REQUEST.RESPONSE.close()
   
   
       def getRDF(self,urn=None):
               """rdf"""
               ret=getRDFDescription(self,self.link,urn=urn)
               return ret+self.createSubElementRDF(urn=urn) 
   
     
       def getAccessRightSelectorHTML(self,outlook="select"):
               """htmlselector"""
               values=['free','mpiwg']
               
               if outlook=="select":
                       ret="""<select name="%s">"""%self.getId()
   
                       for value in values:
                               if value==self.getAccessRightMD():
                                       ret+="<option selected>%s</option>"%value
                               else:
                                       ret+="<option>%s</option>"%value
                       return ret+"</select>"
   
               else:
                       ret=""
                       for value in values:
                               
                               if value==self.getAccessRightMD():
                                       ret+="""<input type="radio" name="%s" value="%s" checked>%s"""%(self.getId(),value,value)
                               else:
                                       ret+="""<input type="radio" name="%s" value="%s">%s"""%(self.getId(),value,value)
                       return ret
   
   
       
       def getAccessRightMD(self):
                   """set accessright"""
                   url=self.metalink
   
     try:      try:
         geturl=""          geturl=""
         for line in urllib.urlopen(url).readlines():                          for line in ECHO_helpers.urlopen(url).readlines():
             geturl=geturl+line              geturl=geturl+line
                   
                   
Line 155  def writeMetadata(url,metadict): Line 468  def writeMetadata(url,metadict):
   
     try:      try:
         dom=xml.dom.minidom.parseString(geturl)          dom=xml.dom.minidom.parseString(geturl)
                           root=dom.getElementsByTagName('resource')[0]
     except:      except:
         return (None,"Cannot parse: "+url+"<br>"+geturl)          return (None,"Cannot parse: "+url+"<br>"+geturl)
   
     metanodes=dom.getElementsByTagName('bib')                  internal=dom.getElementsByTagName('internal')
                   if internal:
                           institution=dom.getElementsByTagName('institution')
                           return getText(institution[0].childNodes)
   
     if not metanodes:                  free=dom.getElementsByTagName('free')
         metanodes=dom.getElementsByTagName('archimedes')                  if free:
                           return "free"
   
     metanode=metanodes[0]                  return "free" #default free
   
     for metaData in metadict.keys():      def changeAccessRightMD(self,accessright,RESPONSE=None):
         print metaData,metanode              """change the rights"""
         try:              
             nodeOld=metanode.getElementsByTagName(metaData)              params="accessright=%s"%accessright
         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:              #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()
                 metanode.removeChild(nodeOld[0]).unlink()  
   
         metanodeneu=dom.createElement(metaData)  
         metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf8"))  
         metanodeneu.appendChild(metanodetext)  
         metanode.appendChild(metanodeneu)  
   
               ECHO_helpers.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()
           
     return dom.topxml().encode('utf-8')  
   
 def readMetadata(url):              if RESPONSE is not None:
     """Methode zum Auslesen der Metadateninformation zu einer Resource                          RESPONSE.redirect('manage_main')
     Vorerst noch Typ bib"""  
                   
       def setAccessRightXML(self,accessright):
                   """set accessright"""
                   url=self.metalink
           
     metadict={}  
     try:      try:
         geturl=""          geturl=""
         for line in urllib.urlopen(url).readlines():                          for line in ECHO_helpers.urlopen(url).readlines():
             geturl=geturl+line              geturl=geturl+line
                   
                   
Line 208  def readMetadata(url): Line 514  def readMetadata(url):
   
     try:      try:
         dom=xml.dom.minidom.parseString(geturl)          dom=xml.dom.minidom.parseString(geturl)
                           root=dom.getElementsByTagName('resource')[0]
     except:      except:
         return (None,"Cannot parse: "+url+"<br>"+geturl)          return (None,"Cannot parse: "+url+"<br>"+geturl)
   
     metanode=dom.getElementsByTagName('bib')                  metanodes=dom.getElementsByTagName('access-conditions')
     metadict['bib_type']='Book'  
     if len(metanode)==0:  
         metanode=dom.getElementsByTagName('archimedes')  
         metadict['bib_type']='Archimedes'  
         #print "HELLO"  
                   
     if not len(metanode)==0:                      if not metanodes:
         metacontent=metanode[0].childNodes                          nodenew=dom.createElement('access-conditions')
                           root.appendChild(nodenew)
                           metanode=nodenew
                   else:
                           metanode=metanodes[0]
           
         try:                  accesses=metanode.getElementsByTagName('access')
             metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)  
         except:  
             """nothing"""  
                   
         for node in metacontent:                  if not accesses:
             try:                          nodenew2=dom.createElement('access')
                 metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)                          metanode.appendChild(nodenew2)
             except:                          metanode2=nodenew2
                 """nothing"""                  else:
                           metanode2=accesses[0]
   
                   internal=metanode.getElementsByTagName('internal')
   
     return metadict,""                  if internal:
                           metanode2.removeChild(internal[0]).unlink()
           
                   free=metanode.getElementsByTagName('free')
   
 def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):                  if free:
                           metanode2.removeChild(internal[0]).unlink()
   
         """Allegemeine Informationen zu einer ECHO Collection"""  
   
         self.viewClassification=viewClassification                  if accessright=='free':
                           nodenew3=dom.createElement('free')
                           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)
   
         self.label = label                  return dom.toxml().encode('utf-8')
         self.title=title  
         self.description=description  
         self.contentType=contentType  
         self.responsible=responsible  
         self.credits=toList(credits)  
         self.weight=weight  
   
         coords=[]      def setStartPageForm(self):
         #coordinates of for rectangles              """Form for changing the startpage"""
   
         #print "cs", coordstrs  
         if coordstrs:  
             for coordstr in coordstrs:  
                 #print "cs", coordstr  
                 try:  
                     temco=coordstr.split(",")  
                 except:  
                     temco=[]  
                 #temco.append(angle)  
                 coords.append(temco)  
   
               pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPage.zpt')
               pt.content_type="text/html"
               return pt()
   
         self.coords=coords[0:]  
                           
       def createImageUrl(self,pn=1):
               """create ImageUrl"""
   
 class scientificClassification(SimpleItem,Persistent,Implicit):  
     """outdated will be deleeted in the next versions: subclass"""  
     security=ClassSecurityInfo()  
           
     def __init__(self,context,science,practice):              resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
         self.context=context  
         self.science=science  
         self.practice=practice  
         self.id="scientific_Classification"  
           
     security.declarePublic('get_context')  
     def get_context(self):  
         return self.context  
       
     security.declarePublic('get_science')  
     def get_science(self):  
         return self.science  
           
     security.declarePublic('get_practice')  
     def get_practice(self):  
         return self.practice  
           
               digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')
               images=readFieldFromXML(self.metalink,'texttool','image')
                                   
 class scientificInformation(Folder,Persistent,Implicit):  
     """outdated will be deleted in the next versions: subclass scientificInformation"""  
     security=ClassSecurityInfo()  
           
               if (not resourcepath) or (not digiliburlprefix) or (not images):
                       zLOG.LOG("ECHO (createImageUrl)",zLOG.ERROR,"Cannot create ImageUrl for %s"%self.absolute_url())
                       return None
               resourcepath=resourcepath.replace('/mpiwg/online','')
               if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"
           
               if (not images) or (not resourcepath): return None
           
     def __init__(self,source_type,period):              return "%sfn=%s&pn=%i"%(digiliburlprefix,resourcepath+"/"+images,pn)
   
         self.id="scientific_Information"      def copyTitleToInfoXML(self,RESPONSE=None):
         self.source_type=source_type              """copy title from the resource"""
         self.period=period              presentationXML=readFieldFromXML(self.metalink,'texttool','presentation')
               resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
               if (not presentationXML) or (not resourcepath): 
                   if RESPONSE:
                           RESPONSE.write("Error: %s\n"%self.getId())
                   else:
                           return None,self.absolute_url()
                   
               try:
                       fh=file(os.path.join(resourcepath,presentationXML),'w')
                       fh.write("""<info>
                       <author></author>
                       <title>%s</title>
                       <date></date>
                       <display>yes</display>
                       </info>"""%self.title)
                       fh.close()
                       return 1,self.getId()
               except:
                       if RESPONSE:
                               RESPONSE.write("Error: %s\n"%self.getId())
                       else:
                               return None,self.absolute_url()
   
   
     security.declarePublic('get_source_type')      def setStartPage(self,startpage=None,RESPONSE=None):
     def get_source_type(self):              """set start page, if no startpage defined use the generic one of the resource"""
         return self.source_type  
           
     security.declarePublic('get_period')              if (not (type(startpage)==StringType)):
     def get_period(self):                      if ("__generic" in startpage): # checke ob generic in der liste
         return self.period                              startpage=self.absolute_url()+"/startpage_html"
                       elif ("__firstPage" in startpage): # checke ob generic in der liste
                               startpage=self.createImageUrl()
   
 class ECHO_layoutTemplate(ZopePageTemplate):              if (not startpage):
     """Create a layout Template for different purposes"""                      startpage=self.absolute_url()+"/startpage_html"
               elif (startpage=="__generic"):
                       startpage=self.absolute_url()+"/startpage_html"
               elif (startpage=="__firstPage"):
                           startpage=self.createImageUrl()
   
     meta_type="ECHO_layoutTemplate"              params="startpage=%s"%startpage
               #print '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))
   
     def __init__(self, id, text=None, content_type=None,EchoType=None):              ECHO_helpers.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()
         self.id = str(id)  
   
   
               path=self.metalink
   
         self.ZBindings_edit(self._default_bindings)              path=re.sub(self.REQUEST['SERVER_URL'],'',path)
         if text is None:              path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
             self._default_content_fn = os.path.join(package_home(globals()),  
                                                'zpt/ECHO_%s_template_standard.zpt'%EchoType)  
             text = open(self._default_content_fn).read()  
         self.pt_edit(text, content_type)  
   
               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://content.mpiwg-berlin.mpg.de','',path) # falls content als server
               path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
               path=re.sub('http://vision.mpiwg-berlin.mpg.de','',path) # falls vision als server
               path=re.sub('http://xserve02.mpiwg-berlin.mpg.de:18880','',path) # falls vision als server
               path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
               path=re.sub('/index.meta','',path) 
           
         """change form"""  
   
               ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
   
 def manage_addECHO_layoutTemplateForm(self):              if RESPONSE is not None:
     """Form for adding"""                          RESPONSE.redirect('manage_main')
     pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_layoutTemplate.zpt').__of__(self)  
       def changeViewerTemplateSetForm(self):
               """change the viewer template set"""
               pt=zptFile(self, 'zpt/changeResourceViewerTemplateSet')
     return pt()      return pt()
   
 from urllib import quote  
   
   
 def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):      def getTextToolsField(self,name,default=''):
     "Add a Page Template with optional file content."          """Lese Textoolsfelder aus index.meta im path aus"""
     if type(EchoType)==StringType:          
         EchoTypes=[EchoType]          try:
               dom=xml.dom.minidom.parse(self.metalink)
               node=dom.getElementsByTagName('texttool')[0] #getNode
               subnode=node.getElementsByTagName(name)[0]
   
               # bei text wird nur der Folder gebraucht
               if name=="text":
                   splitted=getText(subnode.childNodes).split("/")
                   return splitted[len(splitted)-2]
     else:      else:
         EchoTypes=EchoType                  return getText(subnode.childNodes)
           except:
               return default
                   
     for singleType in EchoTypes:  
   
         id = str(singleType)+"_template"      def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
         if REQUEST is None:              """changeit"""
             self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))  
             ob = getattr(self, id)  
                           
             if title:              paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate','digiliburlprefix']
                 ob.pt_setTitle(title)  
             return ob  
         else:  
             file = REQUEST.form.get('file')  
             headers = getattr(file, 'headers', None)  
             if headers is None or not file.filename:  
                 zpt = ECHO_layoutTemplate(id,EchoType=singleType)  
             else:  
                 zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))  
   
             self._setObject(id, zpt)  
             ob = getattr(self, id)  
             if title:  
                 ob.pt_setTitle(title)  
   
             try:              #writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)
                 u = self.DestinationURL()  
             except AttributeError:  
                 u = REQUEST['URL1']  
   
               params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
                           
     REQUEST.RESPONSE.redirect(u+'/manage_main')  
     return ''  
   
 class ECHO_resource(Folder):              ECHO_helpers.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()
     """ECHO Ressource"""  
     meta_type='ECHO_resource'  
   
     viewClassificationList=viewClassificationListMaster              #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)
               # hack Pfad auf die Dokumente
               path=self.metalink
   
     getSubCols = ECHO_helpers.getSubCols  
     def getTitle(self):  
     """title"""  
     return self.title.encode('utf-8')   
   
     def getLabel(self):  
     """title"""  
     return self.label.encode('utf-8')   
   
               path=re.sub('/index.meta','',path) 
   
               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: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('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
               path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
   
               path=re.sub('http://vision.rz-berlin.mpg.de','',path) # falls vision als server
   
               return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
   
   
               if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
       
   
       security.declarePublic('content_html')      
     def content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content"""
         return content_html(self,'resource')          return ECHO_basis.content_html(self,'resource')
           
     def getViewClassification(self):  #    def getViewClassification(self):
         if hasattr(self,'viewClassification'):  #        if hasattr(self,'viewClassification'):
             return self.viewClassification  #            return self.viewClassification
         else:  #        else:
             return ""  #            return ""
   
     def getFullTextXML(self,noredirect=None):      def getFullTextXML(self,noredirect=None):
         """getFullTextXML"""              """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
   
         try:          try:
             fh=urllib.urlopen(self.metalink)                      #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"open %s"%self.metalink)
                       fh=ECHO_helpers.urlopen(self.metalink)
                       #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"opened %s"%self.metalink)
             dom=xml.dom.minidom.parse(fh)              dom=xml.dom.minidom.parse(fh)
             texttools=dom.getElementsByTagName('texttool')              texttools=dom.getElementsByTagName('texttool')
             text=texttools[0].getElementsByTagName('text')              text=texttools[0].getElementsByTagName('text')
             texturl=getText(text[0].childNodes)              texturl=getText(text[0].childNodes)
   
                       #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"found %s"%texturl)
                       fh.close()
                       #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"closed fh")
                       #keine url
                       if not (texturl.split(":")[0] in ['http','ftp','file']): 
             if not noredirect:              if not noredirect:
                               return file(texturl).read()
                           else:
                               return texturl
   
                       if not noredirect:
                               self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
                               zLOG.LOG("ECHO Fulltext",zLOG.INFO,"redirect to:%s"%texturl)
                 self.REQUEST.RESPONSE.redirect(texturl)                  self.REQUEST.RESPONSE.redirect(texturl)
             else:              else:
                 return texturl                  return texturl
         except:          except:
             return None  
                       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>"
   
       def getImagePath(self):
               """gibt pfad zum image aus"""
               return self.getImageView(noredirect="yes",onlyPath="yes")
       
       def getImageView(self,noredirect=None,onlyPath=None):
               """getImages; give Imageviewr  and <error></error> if somthing goes wrong."""
               try:
                       fh=ECHO_helpers.urlopen(self.metalink)
                       dom=xml.dom.minidom.parse(fh)
                       texttools=dom.getElementsByTagName('texttool')
                       text=texttools[0].getElementsByTagName('image')
                       imagetemp=getText(text[0].childNodes)
                       
                       text=dom.getElementsByTagName('archive-path')
                       archivepath=getText(text[0].childNodes)
                       archivepath=re.sub('/mpiwg/online/','',archivepath) 
                       imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp
                       fh.close()
   
                       if not noredirect:
                               self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
                               self.REQUEST.RESPONSE.redirect(imageurl)
                       else:
                               if not onlyPath:
                                       return imageurl
                               else:
                                       return archivepath+"/"+imagetemp
               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 images available</error>"
   
       
       def getCopyrightsHTML(self):
               """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
               
               if hasattr(self,'copyrightModel'):
                       obj=self.copyrightModel
                       
               else:
                       return "ERROR"
               ret=[]
               
               for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
                       
                       
                       try:
                           if hasattr(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
                           url=getattr(copyrightTypeObj, 'url', '')
                               
                           if url!='':
                                    ret.append((url,copyright[0],copyright[1],copyright[2],label))
                           else:
                                   if hasattr(copyrightTypeObj, 'copyright.html'):
                                        ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
                                   else:
                                        ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
                       except:
                               """nothing"""
                       
               return ret
               
       def getInstitutionsHTML(self):
                   """gibt Liste der foerdernden Institutionen aus"""
                   
                   if hasattr(self,'support'):
                           obj=self.support
                           ret=obj.getSupporter()
                           return ret
                   else:
                           return ''
                           
           
     def getCredits(self):      def getCredits(self):
         """Ausgabe der credits"""          """Ausgabe der credits"""
Line 428  class ECHO_resource(Folder): Line 864  class ECHO_resource(Folder):
         else:          else:
             return []              return []
           
     def __init__(self,id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords):  
       
       def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
   
         self.id = id          self.id = id
         """Festlegen der ID"""          """Festlegen der ID"""
Line 441  class ECHO_resource(Folder): Line 879  class ECHO_resource(Folder):
         self.credits=toList(credits)          self.credits=toList(credits)
         self.description=description          self.description=description
         self.contentType=contentType          self.contentType=contentType
           self.copyrightType=copyrightType
           self.renderingType=renderingType
         self.responsible=responsible          self.responsible=responsible
           self.resourceID=resourceID
                   
         if coords:          if coords:
             coordsnew=[ string.split(x,",") for x in coords]              coordsnew=[ string.split(x,",") for x in coords]
Line 449  class ECHO_resource(Folder): Line 890  class ECHO_resource(Folder):
             coordsnew=[]              coordsnew=[]
                   
         self.coords=coordsnew          self.coords=coordsnew
   #       self.viewClassification=""
   
     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  
   
           
   
Line 486  class ECHO_resource(Folder): Line 918  class ECHO_resource(Folder):
         if not hasattr(self,'weight'):          if not hasattr(self,'weight'):
             self.weight=""              self.weight=""
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)          pt=zptFile(self, 'zpt/ChangeECHO_resource.zpt')
         return pt()          return pt()
           
   
     def ECHO_resource_config_main(self):      def ECHO_resource_config_main(self):
         """Main configuration"""          """Main configuration"""
   
         if not hasattr(self,'weight'):          if not hasattr(self,'weight'):
             self.weight=""              self.weight=""
           pt=zptFile(self, 'zpt/ChangeECHO_resource_main.zpt')
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)  
         return pt()          return pt()
   
     def ECHO_resource_config_coords(self):      def ECHO_resource_config_coords(self):
         """Coords configuration """          """Coords configuration """
           pt=zptFile(self, 'zpt/ChangeECHO_resource_coords.zpt')
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_coords.zpt').__of__(self)  
         return pt()          return pt()
   
     def ECHO_resource_config_credits(self):      def ECHO_resource_config_credits(self):
         """Main configuration"""          """Main configuration"""
           pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)  
         return pt()          return pt()
   
     def ECHO_resource_config_metadata(self):      def ECHO_resource_config_metadata(self):
         """Main configuration"""          """Main configuration"""
   
     if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):      if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
         self.metaDataHash={}          self.metaDataHash={}
         self.contentType=self.bib_type          self.contentType=self.bib_type
         for data in self.metadata:          for data in self.metadata:
             data_neu=re.sub('-','_',data)              data_neu=re.sub('-','_',data)
             self.metaDataHash[data_neu]=getattr(self,data)                          self.meta
             #print data_neu, getattr(self,data)                          DataHash[data_neu]=getattr(self,data)[0:]
         #print self.metaDataHash,self.metadata  
           
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)          
           pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')
         return pt()          return pt()
   
   
           
   
     def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):      def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):
         """Änderung der Properties"""          """Aenderung der Properties"""
     self.resourceID=resourceID      self.resourceID=resourceID
     self.title=title      self.title=title
     self.label=label      self.label=label
Line 547  class ECHO_resource(Folder): Line 974  class ECHO_resource(Folder):
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):      def changeECHO_resource_coords(self,RESPONSE=None):
         """Änderung der Properties - coords"""          """Aenderung der Properties - coords"""
           #return self.REQUEST
     if type(coords)==StringType:          for area in self.getMapAreas():
             coords=[coords]              id = area.getId()
               if self.REQUEST.has_key('del.'+id):
         try:                          # delete this area
             coordsnew=[ string.split(x,",") for x in coords]                  self._delObject(id)
         except:                  # return to same menu
         coordsnew=[]                      if RESPONSE is not None:
                       RESPONSE.redirect('ECHO_resource_config_coords')
     self.coords=coordsnew[0:]                  return
     self.viewClassification=viewClassification              # modify this area
                       coordstring = self.REQUEST.get('coords.'+id, '')
               coords = string.split(coordstring, ',')
               angle = self.REQUEST.get('angle.'+id, '0')
               type = self.REQUEST.get('type.'+id, 'area')
               if len(coords) == 4:
                   area.setCoordString(coordstring)
                   area.setAngle(angle)
                   area.setType(type)
           # return to main menu    
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):      def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
         """Änderung der Properties"""          """Aenderung der Properties"""
     self.credits=credits      self.credits=credits
     self.responsible=responsible      self.responsible=responsible
     self.copyrightType=copyrightType      self.copyrightType=copyrightType
Line 574  class ECHO_resource(Folder): Line 1010  class ECHO_resource(Folder):
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
       def changeECHO_resource_metadata_local(self,RESPONSE=None):
               """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:]
                           
   
                       
               if RESPONSE is not None:
                       RESPONSE.redirect('manage_main')
   
     def changeECHO_resource_metadata(self,RESPONSE=None):      def changeECHO_resource_metadata(self,RESPONSE=None):
         """change metadata"""          """change metadata"""
         tags=self.findTagsFromMapping(self.contentType)          tags=self.findTagsFromMapping(self.contentType)
Line 585  class ECHO_resource(Folder): Line 1032  class ECHO_resource(Folder):
             except:              except:
                 """nothing"""                  """nothing"""
   
         return urllib.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML')).read()              ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML')).read()
   
                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def newMetaXML(self):      def getMDValue(self,fieldName,empty=None):
               if not empty:
                       return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)
               
               else:
                       return self.metaDataHash.get(fieldName,empty)
               
       def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
         """new index.meta"""          """new index.meta"""
         self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')          self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
         return writeMetadata(self.metalink,self.OSAS_meta)  
   
               if not hasattr(self,'metaDataHash'):
                   
                       self.copyIndex_meta2echo_resource()
               try:
                       return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
               except:
                       return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
           
     def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):      def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
         """Änderung der Properties"""              """return bibliographical metadata as stored in the object"""
                   
     try:              try:        
             coordsnew=[ string.split(x,",") for x in coords]                      
                       return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
         except:          except:
         coordsnew=[]                          return "<error> no metadata stored</error>"
                   
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)      def getXQueryMetaData(self,xquery):
     self.viewClassification=viewClassification                  '''
         self.coords=coordsnew[0:]                  execute an xquery on the metadata and returns a list of tuples, 
                   each tuple represent the content of the node as text and the whole node as xml-fragment
                   @param xquery: xquery auf den metadaten
                   '''
                   
                   try:
                           md=writeMetadata(self.metalink,self.metaDataHash,xmlfrag="yes")
                   except:
                           return None
   
                   dom = NonvalidatingReader.parseString(md,"http://www.mpiwg-berlin.mpg.de/")
                   
                   results=Ft.Xml.XPath.Evaluate(xquery, contextNode=dom)
               
                   ret=[]
                   for result in results:
                       
                       buf = cStringIO.StringIO()
                       PrettyPrint(result, stream=buf)
                       str = buf.getvalue()[0:]
                       buf.close()
                       ret.append((getTextFromNode(result),str)) 
                           
                   return ret
           
       def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
               """prints out metadata as stored in the echo environment, format is the index.meta format"""
               self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
               return writeMetadata(self.metalink,self.metaDataHash)
   
       def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
           """Aenderung der Properties"""
           
           setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
         self.link=link          self.link=link
         self.metalink=metalink          self.metalink=metalink
                   
Line 617  class ECHO_resource(Folder): Line 1112  class ECHO_resource(Folder):
                           
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Main Config','action':'ECHO_resource_config_main'},          {'label':'Main Config','action':'ECHO_resource_config_main'},
     {'label':'Change Credits & Copyright','action':'ECHO_resource_config_credits'},  
     {'label':'Change Metadata','action':'ECHO_resource_config_metadata'},      {'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
     {'label':'Change Coords','action':'ECHO_resource_config_coords'},          {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
     {'label':'Add coords','action':'ECHO_graphicEntry'},  
         {'label':'Sync Metadata','action':'ECHO_getResourceMD'},          {'label':'Sync Metadata','action':'ECHO_getResourceMD'},
           {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
           {'label':'set/change startpage','action':'setStartPageForm'},
           {'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')  
   
   
     def isDefinedInThisSet(self,fields,field):      def isDefinedInThisSet(self,fields,field):
         """checks if field is defined in fields"""          """checks if field is defined in fields"""
Line 687  class ECHO_resource(Folder): Line 1157  class ECHO_resource(Folder):
                   
     def getFieldValue(self,field):      def getFieldValue(self,field):
         """get value"""          """get value"""
     #print field          
         try:          try:
           
             ret=self.metaDataHash[field]              ret=self.metaDataHash[field]
             if ret == "":              if ret == "":
                 return None                  return None
             else:              else:
                       
                 return ret                  return ret
         except:          except:
             return None              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))
       
   
     def findLabelsFromMapping(self,referenceType):      def findLabelsFromMapping(self,referenceType):
         """gib hash mit label -> generic zurueck"""          """gib hash mit label -> generic zurueck"""
         self.referencetypes=self.ZopeFind(self.standardMD)          #return {},[]
     #print "RT",referenceType  
           temp=self.ZopeFind(self.standardMD)
   
           if referenceType=="":
                   referenceType="book"
           
           
         bibdata={}          bibdata={}
         retdata={}          retdata={}
           fields=[]
         fieldlist=self.standardMD.fieldList          fieldlist=self.standardMD.fieldList
                   
           tags=self.findTagsFromMapping(self.contentType)
           self.referencetypes=tags[2]
     for referenceTypeF in self.referencetypes:      for referenceTypeF in self.referencetypes:
         #print referenceTypeF[1].title,referenceType      
         if referenceTypeF[1].title.lower() == referenceType.lower():          if referenceTypeF[1].title.lower() == referenceType.lower():
             #print "OK"  
             try:              try:
                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields                  bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
                 referenceType=referenceTypeF[1].title                  referenceType=referenceTypeF[1].title
Line 719  class ECHO_resource(Folder): Line 1217  class ECHO_resource(Folder):
                   
   
             bibdata['data']=referenceTypeF[1]              bibdata['data']=referenceTypeF[1]
             self.fields=bibdata[referenceType]                          fields=bibdata[referenceType]
                         for field in fieldlist:                          for field in fieldlist:
                             retdata[field]=referenceTypeF[1].getValue(field)[1]                              retdata[field]=referenceTypeF[1].getValue(field)[1]
     #print retdata,fieldlist  
         return retdata,fieldlist          return retdata,fieldlist,temp,fields
   
     def findTagsFromMapping(self,referenceType):      def findTagsFromMapping(self,referenceType):
         """gib hash mit label -> generic zurueck"""          """gib hash mit label -> generic zurueck"""
         self.referencetypes=self.ZopeFind(self.standardMD)          
   
           if referenceType=="":
                   referenceType="book"
           
           temp =  self.ZopeFind(self.standardMD)[0:]
   
           
           #self.referencetypes=temp[0:]
           
           
           
   
           
           
         bibdata={}          bibdata={}
         retdata={}          retdata={}
         fieldlist=self.standardMD.fieldList          fieldlist=self.standardMD.fieldList
                   fields=[]
     for referenceTypeF in self.referencetypes:          for referenceTypeF in temp:
                   #print referenceType
           
         if referenceTypeF[1].title.lower() == referenceType.lower():           if referenceTypeF[1].title.lower() == referenceType.lower(): 
             try:              try:
Line 743  class ECHO_resource(Folder): Line 1254  class ECHO_resource(Folder):
             except:              except:
                 bibdata[referenceType]=referenceTypeF[1].fields                  bibdata[referenceType]=referenceTypeF[1].fields
             bibdata['data']=referenceTypeF[1]              bibdata['data']=referenceTypeF[1]
             self.fields=bibdata[referenceType]                          fields=bibdata[referenceType]
                         for field in fieldlist:                          for field in fieldlist:
                             retdata[field]=referenceTypeF[1].getValue(field)[0]                              retdata[field]=referenceTypeF[1].getValue(field)[0]
           
         return retdata,fieldlist          return retdata,fieldlist,temp,fields
   
       
       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.absolute_url()
           
               self.contentType=metadict['bib_type'][0:]
               fields=self.findTagsFromMapping(self.contentType)
                           
     def ECHO_getResourceMD(self,template="yes"):              #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"""          """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
         (metadict, error)=readMetadata(self.metalink)          (metadict, error)=readMetadata(self.metalink)
   
           if back:
               self.REQUEST.SESSION['back']=back
   
         if not error=="": #Fehler beim Auslesen des Metafiles          if not error=="": #Fehler beim Auslesen des Metafiles
         return "ERROR:",error          return "ERROR:",error
           
           if not self.contentType:
                   self.contentType=metadict['bib_type'].lower()
   
     if not (metadict['bib_type'].lower()==self.contentType.lower()):      if not (metadict['bib_type'].lower()==self.contentType.lower()):
         self.REQUEST.SESSION['contentStorage']=metadict['bib_type']          self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
         self.REQUEST.SESSION['contentZope']=self.contentType          self.REQUEST.SESSION['contentZope']=self.contentType
   
         return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()                  return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
                   
         self.REQUEST.SESSION['metadict']=metadict          self.REQUEST.SESSION['metadict']=metadict
   
     self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)          
           
           self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])
           
   
                   
         if template=="yes":          if template=="yes":
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)                  pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')
             return pt()              return pt()
   
   
           
           
       
     def ECHO_getMD(self,item):      def ECHO_getMD(self,item):
         """Ausgabe der MD"""          """Ausgabe der MD"""
         return getattr(self,item)          return getattr(self,item)
                   
       def checkRDF(self,path):
               """check if pdf in the path"""
               try:
                       for fileName in os.listdir(path):
                               if os.path.splitext(fileName)[1]==".pdf":
                                       return os.path.join(path,fileName)
                       return None
               except:
                       return None
               
               
       security.declareProtected('View','index_html')
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
                   pdf=self.checkRDF(self.link)
           if pdf:
                   fh=file(pdf,'r').read()
                   self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')
                   self.REQUEST.RESPONSE.write(fh)
                   self.REQUEST.RESPONSE.close()
                   return 
         return self.REQUEST.RESPONSE.redirect(self.link)          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
   
               sp=self.ZopeFind(self,obj_ids=['startpage.html'])
   
               if sp:
                       return sp[1]()
   
               #pruefen ob irgendwo ein template
               if hasattr(self,'startpage_index_template'): 
                       return self.startpage_index_template()
   
               #generisches template ausgeben
               
               pt=zptFile(self, 'zpt/ECHO_startpage_index_template_standard.zpt')
               pt.content_type="text/html"
               return pt()
   
       def toc_html(self):
               
               sp=self.ZopeFind(self,obj_ids=['toc.html'])
                       
               if sp:
                       return sp[0][1]()
   
   
       security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
   
     def generate_label(self):      def generate_label(self):
         """Erzeugt_standard_Label aus Template"""          """Erzeugt_standard_Label aus Template"""
         pt=getattr(self,"label_template_"+self.bib_type)          pt=getattr(self,"label_template_"+self.contentType.lower())
   
           self.label=pt()[0:]
           return pt()
   
       security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination
   
       def generate_title(self,RESPONSE=None):
           """Erzeugt_standard_Label aus Template"""
           pt=getattr(self,"label_template_"+self.contentType.lower())
   
           self.title=pt()[0:]
   
         return pt()          return pt()
   
   Globals.InitializeClass(ECHO_resource)
   
 def manage_addECHO_resourceForm(self):  def manage_addECHO_resourceForm(self):
         """Form for adding a ressource"""          """Form for adding a ressource"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)          pt=zptFile(self, 'zpt/AddECHO_resourceForm.zpt')
         return pt()          return pt()
   
   
   
 def manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):  def manage_addECHO_resource(self,id,title,label,description="",responsible="",link="",metalink="",weight="",copyrightType=None,resourceID=None,contentType=None,renderingType=None,credits=None,coords=None,RESPONSE=None):
     """addaresource"""      """addresource"""
   
     newObj=ECHO_resource(id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords)      newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
   
Line 813  def manage_addECHO_resource(self,id,titl Line 1418  def manage_addECHO_resource(self,id,titl
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
     
   
 class ECHO_externalLink(Folder):  class ECHO_externalLink(Folder,ECHO_basis):
     """Link zu einer externen Ressource"""      """Link zu einer externen Ressource"""
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type='ECHO_externalLink'      meta_type='ECHO_externalLink'
   
     def getTitle(self):      security.declarePublic('content_html')
     """title"""  
     return self.title.encode('utf-8')   
   
     def getLabel(self):  
     """title"""  
     return self.label.encode('utf-8')   
   
     def content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content"""
         return content_html(self,'externalLink')          return ECHO_basis.content_html(self,'externalLink')
           
     def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):      def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
   
Line 854  class ECHO_externalLink(Folder): Line 1452  class ECHO_externalLink(Folder):
         if not hasattr(self,'coords'):          if not hasattr(self,'coords'):
                           
             self.coords=['']              self.coords=['']
             #print "G",self.coords  
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)  
           pt=zptFile(self, 'zpt/ChangeECHO_externalLink.zpt')
         return pt()          return pt()
           
   
     def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):      def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
           """Aenderung der Properties"""
           setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
   
         """Änderung der Properties"""  
     try:  
         coordsnew=[ string.split(x,",") for x in coords]  
     except:  
         coordsnew=[]  
   
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)  
   
         self.coords=coordsnew[0:]  
         self.link=link          self.link=link
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
Line 878  class ECHO_externalLink(Folder): Line 1469  class ECHO_externalLink(Folder):
                           
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Main Config','action':'ECHO_externalLink_config'},          {'label':'Main Config','action':'ECHO_externalLink_config'},
           {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
         )          )
   
     def getCredits(self):  
         """Ausgabe der credits"""  
         if self.credits:  
             return self.credits  
         else:  
             return []  
                   
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
Line 894  class ECHO_externalLink(Folder): Line 1480  class ECHO_externalLink(Folder):
   
 def manage_addECHO_externalLinkForm(self):  def manage_addECHO_externalLinkForm(self):
         """Form for external Links"""          """Form for external Links"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)          pt=zptFile(self, 'zpt/AddECHO_externalLinkForm.zpt')
         return pt()          return pt()
   
   
Line 914  class ECHO_link(ECHO_externalLink): Line 1500  class ECHO_link(ECHO_externalLink):
   
     meta_type="ECHO_link"      meta_type="ECHO_link"
           
           def ECHO_link_addLinksForm(self):
               """Main configuration"""
           
               pt=zptFile(self, 'zpt/ChangeECHO_link_addLinks.zpt')
               return pt()
       
           def ECHO_link_addLinks(self,addLinks,RESPONSE):
               """add links"""
               self.addLink=addLink
               if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
   
     def content_html(self):      def content_html(self):
         """template fuer link"""          """template fuer link"""
                   
         if hasattr(self,"link_template"):          if hasattr(self,"link_template"):
             return content_html(self,'link')                          ret=ECHO_basis.content_html(self,'link')
                   else:
                           ret=ECHO_basis.content_html(self,'collection')
   
                   try:
                       return ret.decode('utf-8')
                   except:
                       return ret
                   
           def index_html(self):
                   """standard link"""
                   if self.link:
                    splitted=self.link.split("?")
                    if len(splitted)>1:
                           params=cgi.parse_qs(splitted[1])
   
                           for x in params.keys():
                                   if type(params[x]) is ListType:
                                           params[x]=params[x][0]
           
   
         else:          else:
             return content_html(self,'collection')                          params={}
                   
                    if getattr(self,'addLinks','yes')=="yes":
                        params['backLink']=self.aq_parent.absolute_url()
                        params['startLink']=splitted[0]+"?"+urllib.urlencode(params)
                   
                   
                    return self.REQUEST.RESPONSE.redirect(splitted[0]+"?"+urllib.urlencode(params))
                   else:
                    return ""
           
 def manage_addECHO_linkForm(self):  def manage_addECHO_linkForm(self):
         """Form for external Links"""          """Form for external Links"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)          pt=zptFile(self, 'zpt/AddECHO_linkForm.zpt')
         return pt()          return pt()
   
   
 def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):  def manage_addECHO_link(self,id,title,label,description="",contentType="",responsible="",link="",weight="",coords=[],credits=None,RESPONSE=None):
     """Add an external Link"""      """Add an external Link"""
   
     newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)      newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
   
       getattr(self,id).addLinks='no'
       
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
   
 class ECHO_collection(Folder, Persistent, Implicit):  class ECHO_collection(Folder, Persistent, Implicit, Cacheable,ECHO_basis):
     """ECHO Collection"""      """ECHO Collection"""
   
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type='ECHO_collection'      meta_type='ECHO_collection'
     viewClassificationList=viewClassificationListMaster  #    viewClassificationList=viewClassificationListMaster
     displayTypes=displayTypes      displayTypes=displayTypes
   
     def getViewClassification(self):      path="/mpiwg/online/permanent/shipbuilding"
         if hasattr(self,'viewClassification'):  
             return self.viewClassification      def getTitleAndLabel(self):
           """gibt title und label zurueck"""
           return (getattr(self,'title',''),getattr(self,'label',''))
   
       def localizeObjects(self):
               """localize all objects"""
               contents=self.ZopeFind(self,obj_metatypes=['ECHO_externalLink','ECHO_link','ECHO_mapText'])
   
               find=self.ZopeFind(self,obj_ids=('locale_en'))
               if not find:
                   self.manage_addECHO_locale("en",'','')
               for content in contents:
   
                       if content[1].meta_type in ['ECHO_link','ECHO_externalLink']:
   
                               find=content[1].ZopeFind(content[1],obj_metatypes=('ECHO_mapText'))
                               if find:
                                       root=find[0][1]
   
                                       locale=find[0][1].ZopeFind(find[0][1],obj_ids=('locale_en'))
         else:          else:
             return ""                                      root=None
                       else:
                               root=content[1]
                               locale=content[1].ZopeFind(content[1],obj_ids=('locale_en'))
                       if root and not locale:
                               root.manage_addECHO_locale("en",'','')
                       
               pt=zptFile(self, 'zpt/localizeObjects.zpt')
               return pt()
   
     def getTitle(self):  
     """title"""  
     return self.title.encode('utf-8')   
   
     def getLabel(self):      def localize(self,REQUEST,RESPONSE):
     """title"""              """localize"""
     return self.label.encode('utf-8')               for key in REQUEST.form.keys():
                       splitted=key.split("!")
   
                       if splitted[0]=="" or splitted[0]=="en" or splitted[0]=="title" or splitted[0]=="label":
                               if splitted[0]=="en":
                                       setattr(self.locale_en,splitted[1],REQUEST.form[key])
                               else:
                                       setattr(self,splitted[0],REQUEST.form[key])
                       else:
                               obj=getattr(self,splitted[0])
   
                               if obj.meta_type=="ECHO_mapText":
                                       if splitted[1]=="en":
                                               obj.locale_en.pt_edit(REQUEST.form[key],None)
                                       else:
                                               obj.pt_edit(REQUEST.form[key],None)
                               else:
                                       text=obj.ZopeFind(obj,obj_metatypes=['ECHO_mapText'])
                                       if splitted[1]=="en":
                                               
                                               text[0][1].locale_en.pt_edit(REQUEST.form[key],None)
                                       else:
                                               text[0][1].pt_edit(REQUEST.form[key],None)
               if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
   
       def getRDF(self,urn=None):
               """rdf of the collection"""
               
               contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
   
               ret=getRDFDescription(self,self.absolute_url(),urn=urn)
               
               if not urn:
                       urn=self.absolute_url()
                       
               li="""<RDF:li RDF:resource="%s" />\n"""
   
               
               for content in contents:
                       ret+=content[1].getRDF()+"\n"
                       
               ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
               for content in contents:
                       nurn=content[1].absolute_url()
                       ret+=li%nurn
               return ret+"</RDF:Seq>"
               
   
       
       def changeLabels(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/changeLabelsForm')
                   pt.content_type="text/html"
                   return pt()
   
       def changeTitles(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/changeTitleForm')
                   pt.content_type="text/html"
                   return pt()
   
       def changeWeights(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/changeWeightForm')
                   pt.content_type="text/html"
                   return pt()
   
       def changeMetaDataLinks(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/changeMetaDataLinkForm')
                   pt.content_type="text/html"
                   return pt()
       def changeAccessRightsCollection(self):
               """change"""
               ret=""
               argv=self.REQUEST.form
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
               for resource in resources:
                      
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].changeAccessRightMD(argv[resource[1].getId()])
                       except:
                               pass
               return ret
   
       def changeMetaDataLinkInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
               for resource in resources:
                      
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].metalink=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
       def changeMetaDataLinkInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
               for resource in resources:
                      
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].metalink=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
       def changeWeightsInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
               for resource in resources:
                      
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].weight=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
       def changeTitlesInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
               for resource in resources:
                      
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].title=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
       
       def changeLabelsInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
               for resource in resources:
                      
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].label=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
          
       def updateCollection(self,RESPONSE=None):
           """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
           files=os.listdir(self.path)
           ret=""
           for fileName in files:
               
               if fileName:
                   
                   tempPath=re.sub("/mpiwg/online","",self.path)
                   link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"
                   
                   metalink=self.path+"/"+fileName+"/index.meta"
                   try:
   
                           #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','','','','','','')
                           self._setObject(fileName,newObj)
                   
                           genObj=getattr(self,fileName)
                           #genObj.createIndexFile()
                           ret+="OK:"+fileName+"<br/>"
                   except:
                           print "ERROR"
                           ret+="ERROR:"+fileName+"<br/>"
   
           return ret
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def updateCollectionMD(self,RESPONSE=None):
           """updateMD"""
           files=os.listdir(self.path)
           for fileName in files:
               if fileName:
                   genObj=getattr(self,fileName)
                   genObj.copyIndex_meta2echo_resource()
                   genObj.generate_title()
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
   
       def changeViewerTemplateSetsForm(self):
               """change the viewer template set"""
               pt=zptFile(self, 'zpt/changeViewerTemplateSet')
               return pt()
   
       def getViewerTemplateSets(self,obj_ids=None,RESPONSE=None):
               """Get the ViewerTemplateSet title for configuration"""
               ret=[]
               
               try:
                       viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.
               
                       for viewerTemplateSet in viewerTemplateSets:
                               ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))
   
                       return ret
                       
               except:
                       return [('no ViewerTemplateSetfolders','')]
   
       def getTextToolsField(self,name,default=''):
               """Lese viewerTemplateSet der Collection not implemented yet!"""
               
               return default
   
               
       def isSelectedViewerTemplateSet(self,obj,id):
           """is ausgewaehlt"""
           
           if self.REQUEST['viewerTemplateSet']==id:
               return 1
           else:
               return None
   
       def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
               """change the templates"""
   
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
               for resource in resources:
   
                       resource[1].changeViewerTemplateSet(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
   
               if RESPONSE is not None:
                       RESPONSE.redirect('manage_main')
   
   
       def setStartpageFolderForm(self):
               """Form for changing the startpage"""
   
               
               pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPageFolder.zpt')
               pt.content_type="text/html"
               return pt()
       
       def setStartpageFolder(self,startpage=None,RESPONSE=None):
               """change the templates"""
   
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
               for resource in resources:
   
                       resource[1].setStartPage(startpage)
   
               if RESPONSE is not None:
                       RESPONSE.redirect('manage_main')
   
       def copyTitleToInfoXMLFolder(self,RESPONSE=None):
               """copy title into the title field of info.xml
               author and date werden leer!!!
               """
   
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
               
               
               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)
                       
                       #zLOG.LOG("ECHO (copyTitleToInfoXMLFolder)",zLOG.INFO,txt)   
               if RESPONSE is not None:
                       RESPONSE.write("done!\n")
                       RESPONSE.close()
                       RESPONSE.redirect('manage_main')
                       
       def copySearchFields(self,RESPONSE=None):
               """copys import metadatafields to the object"""
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
   
               for resource in resources:
   
                       resource[1].copySearchFields()
   
               if RESPONSE is not None:
                       RESPONSE.redirect('manage_main')
                       
       def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
               """warning"""
               pt=zptFile(self, 'zpt/reloadMetaDataFromStorageWarning.zpt')
               pt.content_type="text/html"
               return pt()
   
       def reloadMetaDataFromStorage(self,RESPONSE=None):
               """copy metadata from the storage to ECHO"""
   
               return reloadMetaDataFromStorage(self,RESPONSE=None)
   
       
       def getPartnerCopyright(self,name,sonst="generic"):
                   """gibt generisches copyright eines partners aus, sonst behalte jetzige einsteillung"""
                   #print "hi",name,sonst
                   #print getattr(self.partners,name).copyrightType
                   try:
                           partner=getattr(self.partners,name)
                           return partner.copyrightType
                   except:
                           print "error"
                           return sonst
   
       def partnerSelector_HTML(self,selected=None):
            """give type selector"""
            if not selected:
                    retStr="<option selected>\n"
            else:
                    retStr="<option>\n"
                    
            try: # erste version copyrightTypes exists
                    for partner in self.credits:
                            if selected and (partner==selected):
                                    retStr+="""<option selected value="%s">%s\n"""%(partner,partner)
                            else:                
                                    retStr+="""<option value="%s">%s\n"""%(partner,partner)
            except:
                    """nothing"""
            return retStr
    
   #    def getViewClassification(self):
   #        if hasattr(self,'viewClassification'):
   #            return self.viewClassification
   #        else:
   #            return ""
           
                   
     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 982  class ECHO_collection(Folder, Persistent Line 1987  class ECHO_collection(Folder, Persistent
             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'),"","","",link.encode('ascii'),"","")
         return ret          return ret
           
       security.declarePublic('getImageTag')
     def getImageTag(self):      def getImageTag(self):
         """GetTag"""          """GetTag"""
         try:          try:
Line 989  class ECHO_collection(Folder, Persistent Line 1996  class ECHO_collection(Folder, Persistent
         except:          except:
             return ""              return ""
   
   
       def addMovie(self,id,title,label,description,contentType,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits=None,coords=None,RESPONSE=None):
           """SSS"""
   
           #manage_addECHO_movie(self,id,title,label,description,responsible,link,thumbUrl,rawFile,metalink,weight,credits=None,coords=None,RESPONSE=None)
           if not hasattr(self,id):
                   try:
                           manage_addECHO_movie(self,id,title,label,description,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits=None,coords=None,RESPONSE=None)
                           return "done"
                   except:
                           return None
           else:
                   obj=getattr(self,id)
                   obj.changeECHO_movie_main(metalink,link,rawFile,lowresFile,thumbUrl,title,label,description,contentType,weight=weight)
   
           return "changed"
   
     def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):      def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
         """SSS"""          """SSS"""
         try:          try:
             manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)              manage_addECHO_resource(self,id,title,label,description,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
             return "done"              return "done"
         except:          except:
             return None              return None
Line 1011  class ECHO_collection(Folder, Persistent Line 2035  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):
         """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()
         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  
   
           
     security.declarePublic('getCreditObject')      security.declarePublic('getCreditObject')
     def getCreditObject(self,name):      def getCreditObject(self,name):
Line 1157  class ECHO_collection(Folder, Persistent Line 2094  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):  
         """Rerender all Links"""  
         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].ECHO_getResourceMD(template="no")  
             #print "rerender",entry[1].getId()  
         else:  
            self.ECHO_rerenderLinksMD(entry[1])  
   
                   
                   
         return "Rerenderd all links to resources in: "+self.title  
   
     security.declarePublic('ECHO_newViewerLink')      def ECHO_rerenderLinksMDWarning(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/rerenderLinksWarning')
                   pt.content_type="text/html"
                   return pt()
           
   
     def getCoords(self):  
         try:  
                           
             x=  [string.join(x,",") for x in self.coords]        security.declarePublic('ECHO_rerenderLinksMD')
             return x      def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
           """Rerender all Links"""
         except:          return ECHO_rerenderLinksMD(self,obj,types)
   
             return []  
                   
     def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):      def __init__(self,id,title,label,description="",contentType="",responsible="",credits="",weight="",sortfield="",coords=[],secondaryLinkTitle="",secondaryLink="",imageTag="",bgcolour=""):
         #print "CO",coords  
   
         self.id = id          self.id = id
         """Festlegen der ID"""          """Festlegen der ID"""
Line 1211  class ECHO_collection(Folder, Persistent Line 2129  class ECHO_collection(Folder, Persistent
     self.bgcolour=bgcolour      self.bgcolour=bgcolour
                   
   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+ Cacheable.manage_options+(
         {'label':'Main Config','action':'ECHO_collection_config'},          {'label':'Main Config','action':'ECHO_collection_config'},
         {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},          {'label':'Change Labels','action':'changeLabels'},
         {'label':'Graphics','action':'ECHO_graphicEntry'},          {'label':'Change Titles','action':'changeTitles'},
           {'label':'Localize','action':'localizeObjects'},
           {'label':'Change Weights','action':'changeWeights'},
           {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},
           {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
     {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},      {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
           {'label':'Set Startpage','action':'setStartpageFolderForm'},
           {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},
           {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
           {'label':'ImportCollection','action':'updateCollection'},
           {'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 1258  class ECHO_collection(Folder, Persistent Line 2156  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 1275  class ECHO_collection(Folder, Persistent Line 2167  class ECHO_collection(Folder, Persistent
         else:          else:
             return "#dddddd"              return "#dddddd"
                   
     def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",viewClassification=None):                  
       security.declarePublic('changeECHO_collection')         
       def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",location=None,isAlwaysClickable=None,prefix="",suffix=""):
         """Aenderung der Properties"""          """Aenderung der Properties"""
   
         self.secondaryLink=secondaryLink          self.secondaryLink=secondaryLink
         self.secondaryLinkTitle=secondaryLinkTitle          self.secondaryLinkTitle=secondaryLinkTitle
         self.imageTag=imageTag          self.imageTag=imageTag
     self.bgcolour=bgcolour      self.bgcolour=bgcolour
         self.viewClassification=viewClassification          self.location=location
           self.isAlwaysClickable=isAlwaysClickable
           self.prefix=prefix[0:]
           self.suffix=suffix[0:]
           
         if coords:          setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
             coordsnew=[ string.split(x,",") for x in coords]  
             self.coords=coordsnew[0:]  
         else:  
             coordsnew=None  
             self.coords=None  
               
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)  
     try:  
         self.coords=coordsnew[0:] # HACK fehler in setECHO_collection  
         except:  
         """none"""  
                   
         self.sortfield=sortfield          self.sortfield=sortfield
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
     security.declarePublic('index_html')      def setAlwaysClickable(self,flag="yes"):
               """set clickable"""
               if flag=="yes":
                       self.isAlwaysClickable="yes"
               else:
                       self.isAlwaysClickable=None
   
               return flag
   
     def showOverview(self):      def showOverview(self):
         """overview"""          """overview"""
         if 'ECHO_overview.html' in self.__dict__.keys():          if 'ECHO_overview.html' in self.__dict__.keys():
             return getattr(self,'ECHO_overview.html')()              return getattr(self,'ECHO_overview.html')()
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)          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
                   
         if 'index.html' in self.__dict__.keys():          if 'index.html' in self.__dict__.keys():
             return getattr(self,'index.html')()              ret=getattr(self,'index.html')()
                   
         elif 'overview' in self.__dict__.keys():          elif 'overview' in self.__dict__.keys():
             return self.showOverview()              ret=self.showOverview()
         elif hasattr(self,'collection_index_template'):          elif hasattr(self,'collection_index_template'):
             return self.collection_index_template()                  ret=self.collection_index_template()    
         elif hasattr(self,'main_index_template'):          elif hasattr(self,'main_index_template'):
             return self.main_index_template()      
                   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)              ret=self.main_index_template.__of__(self)(self.main_template)
           else:
               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')
           try:
               return ret.decode('utf-8')
           except:
               return ret
           
     def getCredits(self):      def getCredits(self):
         """Ausgabe der credits"""          """Ausgabe der credits"""
Line 1359  class ECHO_collection(Folder, Persistent Line 2267  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=['ECHO_collection','ECHO_resource','ECHO_link','ECHO_externalLink']):
           """Give list of coordinates"""
   
           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
Line 1399  Globals.InitializeClass(ECHO_collection) Line 2305  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=""):
     """add a echo collection"""      """add a echo collection"""
           
   
Line 1421  class ECHO_group(ECHO_collection): Line 2327  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,urn=None):
               """rdf of the collection"""
               contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
   
               ret=getRDFDescription(self,self.absolute_url(),urn=urn)
   
               
               if not urn:
                       urn=self.absolute_url()
               li="""<RDF:li RDF:resource="%s" />\n"""
               
               
               for content in contents:
                       ret+=content[1].getRDF()+"\n"
                       
               ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
               for content in contents:
                       nurn=content[1].absolute_url()
                       ret+=li%nurn
               return ret+"</RDF:Seq>"
               
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
         displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)          displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
Line 1444  class ECHO_group(ECHO_collection): Line 2373  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 1460  class ECHO_group(ECHO_collection): Line 2389  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 1472  class ECHO_group(ECHO_collection): Line 2401  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 1495  class ECHO_group(ECHO_collection): Line 2417  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 1635  def manage_addECHO_userFolderForm(self): Line 2558  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)
   
   
   
   def createNode(self,descrs,node):
           name=descrs[node]['name']
           type=descrs[node]['type']
           urn=node
           #print "    will create",node.encode('utf-8')
           id=re.sub('[^a-zA-Z0-9]','',name).encode('ascii','ignore')
           #print "id",id
           #print type
           #self.REQUEST.RESPONSE.write("<p>%s<p>\n"%id)
           if type=="CDLI_group":
                   
                   try:
                           manage_addECHO_collection(self,id,name,name,"","","","","")
                   
                   except:
                           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 type,getattr(self,id),urn
   
           if type=="CDLI_item":
                   try:
                           manage_addECHO_resource(self,id,name,name,"","",urn,"","")
                   except:
                           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 "XX"
   
   
 class ECHO_root(Folder,Persistent,Implicit):  class ECHO_root(Folder,Persistent,Implicit):
     """ECHO Root Folder"""      """ECHO Root Folder"""
   
Line 1643  class ECHO_root(Folder,Persistent,Implic Line 2600  class ECHO_root(Folder,Persistent,Implic
     meta_type="ECHO_root"      meta_type="ECHO_root"
           
           
       def findObjectFromFulltext(self,existUri):
           '''
           
           @param url:
           @param existUri:
           '''
   
           if existUri:
               #TODO: at the moment assume that the filename is unique, the whole has to changed to a system of ids.
               filename=existUri.split("/")[-1]
           
           founds=self.resourceCatalog.search({'fullTextUrl':os.path.splitext(filename)[0]})  
           
           ret=[(found.title,found.getObject().absolute_url(),found.getObject().aq_parent.absolute_url()) for found in founds]
           
           return ret
           
       def reindex(self,RESPONSE=None):
           """indiziere alle Objecte neu"""
           
           if RESPONSE:
               RESPONSE.write("<html><body>")
           
           resources=self.ZopeFind(self,obj_metatypes=["ECHO_resource"], search_sub=1)
           
           for resource in resources:
               resource[1].reindex()
               print "<p> done %s </p>\n"
               if RESPONSE:
                   RESPONSE.write("<p> done %s </p>\n"%resource[0])
                   
           if RESPONSE:
               RESPONSE.write("<p> ok </p></html></body>\n")
               
       def printer(self,txt):
           print txt
           print txt[2]
           print txt[2].getImageTag()
           print "HO"
           return txt[2].getImageTag()
   
       def printer2(self,txt):
           print txt
   
   
       def item2(self,txt):
           return txt[2]
   
       def setLanguage(self,lang):
               """Set language cookie"""
               self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")
   
       def switchLanguage(self):
               """Set language cookie"""
               if self.getLanguage()=="en":
                       lang="de"
               else:
                       lang="en"
               
               self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")
               self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1'])
       def getLanguage(self):
               """get language cookie"""
               lang= self.REQUEST.cookies.get('lang_exhibition','de')
               if lang == '':
                       lang="de"
               return lang
       
       def getContentOverviewTemplate(self):
           """produces overview template with macro"""
           pt = zptObjectOrFile(self, 'content_overview_template')
           return pt
   
       def mapstyle_css(self):
           """send mapstyle.css"""
           sendFile(self, 'html/ECHO_mapstyle.css', 'text/css')
   
   
       ###Cdli adds -> have to be removed
       def getTablet(self,item):
           #print "getTablet"
           try:
                   read=urllib.urlopen("http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"%item).read()
                   read=re.sub("\[search\]","search",read)
                   return read[read.find("<body>")+6:read.rfind("</body>")]
           except:
                   return "<h1>Sorry no connection to the data server enlil.museum.upenn.edu</h1>"
           #return "http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"
       ###END CDLI add
   
   
       def URLquote(self, text):
           """urllib.quote fuer Michael"""
           return urllib.quote(text)
   
   
       def checkResource(self,id):
               """checks if a resource is in the tree, gives back none or list of resources"""
               if not id:
                   id=""
               splitted=id.split("/")
               id=splitted[len(splitted)-1]
               if hasattr(self,"_v_checkResource") and self._v_checkResource.has_key(id): #existiert ein cache und id ist bereits drin?
                               return self._v_checkResource[id]
   
               else:
                       resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],obj_ids=[id],search_sub=1)
   
                       if not hasattr(self,"_v_checkResource"): self._v_checkResource={}#lege cache an falls nicht existent
                       if resources:
                               self._v_checkResource[id]=resources[0:] # slicing to be sure that data is stabil
                       else:
                               self._v_checkResource[id]=None
                       
                       return self._v_checkResource[id]
               
       def sendForm(self,fromaddr,content,server='mail.mpiwg-berlin.mpg.de'):
               """sendform"""
               toaddrs=["dwinter@mpiwg-berlin.mpg.de"]
               
               msg = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n"
                      % (fromaddr, ", ".join(toaddrs),"testsub"))
               server = smtplib.SMTP(server)
               #server.set_debuglevel(1)
               msg=msg+content
               server.sendmail(fromaddr, toaddrs, msg)
               server.quit()
                    
       def generateFromRDFForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/generateFromRDFForm')
                   pt.content_type="text/html"
                   return pt()
   
       def generateFromRDF(self,file,startNode="/Cuneiform Corpus"):
   
               """generate from RDF"""
   
               global seqs
               seqs={}
               global descrs
               descrs={}
               global key
               key=""
               global value
               value=""
   
               def getEdges(seqs,urn):
                       """edges"""
                       ret=[]
                       return seqs[urn]
   
               def createSubs(self,seqs,descrs,urn,level=0):
                       """create subs"""
                       for edge in getEdges(seqs,urn):
                               cn=createNode(self,descrs,edge)
                               if cn[0]=="CDLI_group":
                                       createSubs(cn[1],seqs,descrs,cn[2],level+1)
                       return
   
               def start_element(name,attrs):
   
                       global seqs
                       global descrs
                       global key
                       global value
                       seq=""
                       if name=="RDF:Seq":
                               key=attrs.get('RDF:about')
                               try: # teste ob liste
                                       x=seqs[key][0]
                               except:
   
                                       seqs[key]=[]
   
                       
                       elif name=="RDF:Description":
                               key=attrs.get('RDF:about')
                               
   
                       elif name=="RDF:li":
                               name=attrs.get('RDF:resource')
                               seqs[key].append(name)
   
                       elif name=="ECHONAVIGATION:type":
                               value="type"
   
                       elif name=="ECHONAVIGATION:name":
                               value="name"
                       elif name=="ECHONAVIGATION:linkClickable":
                               value="linkClickable"
                               
               def end_element(name):
                               """nothing"""
                               key=""
                               value=""
   
               def char_data(data):
                       """nothing"""
   
                       data=re.sub("\n","",data)
                       try:
                               if descrs[key].has_key(value):
                                       descrs[key][value]+=data
                               else:
                                       descrs[key][value]=data
                       except:
   
                               descrs[key]={}
                               descrs[key][value]=data
                               
               p = xml.parsers.expat.ParserCreate()
               
               p.StartElementHandler = start_element
               p.EndElementHandler = end_element
               p.CharacterDataHandler = char_data
               
               
               p.ParseFile(file)
               self.REQUEST.RESPONSE.write("<html><body><h1>Start</h1>")
               createSubs(self,seqs,descrs,startNode)
               self.REQUEST.RESPONSE.write("<h1>done</h1></body></html>")
               #print "done"
   
               
               return "done"
       
               
   
                   
       def changeWeightsInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
               for resource in resources:
                      
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].weight=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
       def changeWeights(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/changeWeightForm')
                   pt.content_type="text/html"
                   return pt()
       getSubCols = ECHO_helpers.getSubCols
   
       manage_options=Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_copyright_configForm'},
                   {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
                   {'label':'Change Weights','action':'changeWeights'},
                   {'label':'Generate from RDF','action':'generateFromRDFForm'},
   
   )
   
       
   
       def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
               """warning"""
               pt=zptFile(self, 'zpt/reloadMetaDataFromStorageWarning.zpt')
               pt.content_type="text/html"
               return pt()
   
       def reloadMetaDataFromStorage(self,RESPONSE=None):
               """reload MD from Storage"""
   
               return reloadMetaDataFromStorage(self,RESPONSE)
       
       def getRDF(self,urn=None):
               """rdf of the collection"""
   
               contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
   
               ret=getRDFDescription(self,self.absolute_url(),urn=urn)
               
               li="""<RDF:li RDF:resource="%s" />\n"""
   
               
               for content in contents:
                       ret+=content[1].getRDF()+"\n"
                       
               ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
               for content in contents:
                       nurn=content[1].absolute_url()
                       ret+=li%nurn
               return ret+"</RDF:Seq>"
               
   
       def showContent(self,path):
               """return content/html"""
               
               return ECHO_helpers.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 for 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:
                       
                       return getattr(found,field).decode('ascii','ignore')
               except:
                       return ""
   
       security.declarePublic('getImageTag')
     def getImageTag(self):      def getImageTag(self):
         """needed by main_template"""          """needed by main_template"""
         return ""          return ""
           
     secondaryLink="" #needed by main_template      secondaryLink="" #needed by main_template
     secondaryLinkTitle="" #needed by main_template      secondaryLinkTitle="" #needed by main_template
           
Line 1653  class ECHO_root(Folder,Persistent,Implic Line 2935  class ECHO_root(Folder,Persistent,Implic
     """hack"""      """hack"""
     return "#dddddd"      return "#dddddd"
   
       security.declareProtected('View','contentTypeSelector_HTML')
     def contentTypeSelector_HTML(self,selected=None):      def contentTypeSelector_HTML(self,selected=None):
         """give type selector"""          """give type selector"""
         if not selected:          if not selected:
Line 1695  class ECHO_root(Folder,Persistent,Implic Line 2978  class ECHO_root(Folder,Persistent,Implic
          """nothing"""           """nothing"""
      return retStr       return retStr
   
     def renderingTypeSelector_HTML(self,selected=None):  
       def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):
          """give type selector"""           """give type selector"""
   
            if not first:
      if not selected:       if not selected:
          retStr="<option selected>\n"           retStr="<option selected>\n"
      else:       else:
          retStr="<option>\n"           retStr="<option>\n"
            else:
                    if not selected:
                            retStr="""<option selected value="%s">%s\n"""%first
                    else:
                            retStr="""<option value="%s">%s\n"""%first
                     
      try: # erste version renderingTypes exists           
          for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):           try: # erste version copyrightTypes exists
              if selected and (renderingType[0]==selected):                   for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
                  retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])                           if selected and (copyrightType[0]==selected):
                                    retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
              else:                               else:                
                  retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])                                   retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
                    
                    for copyrightTypeSelf in self.ZopeFind(object,obj_metatypes=["ECHO_copyrightType"],search_sub=1):
                            if selected and (copyrightTypeSelf[0]==selected):
                                    retStr+="""<option selected value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
                            else:                
                                    retStr+="""<option value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
                                    
      except:       except:
          """nothing"""           """nothing"""
      return retStr  
   
            return retStr
   
     def copyrightTypeSelector_HTML(self,selected=None):      def partnerSelector_HTML(self,selected=None):
          """give type selector"""           """give type selector"""
      if not selected:       if not selected:
          retStr="<option selected>\n"           retStr="<option selected>\n"
Line 1721  class ECHO_root(Folder,Persistent,Implic Line 3020  class ECHO_root(Folder,Persistent,Implic
          retStr="<option>\n"           retStr="<option>\n"
                     
      try: # erste version copyrightTypes exists       try: # erste version copyrightTypes exists
          for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):                   for copyrightType in self.ZopeFind(self.partners,obj_metatypes=["ECHO_partner"]):
              if selected and (copyrightType[0]==selected):               if selected and (copyrightType[0]==selected):
                  retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])                   retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
              else:                               else:                
Line 1730  class ECHO_root(Folder,Persistent,Implic Line 3029  class ECHO_root(Folder,Persistent,Implic
          """nothing"""           """nothing"""
      return retStr       return retStr
   
       mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version ueber echoroot??
   
       def mediaTypeSelector_HTML(self,selected=None):
            """give type selector"""
            if not selected:
                    retStr="<option selected>\n"
            else:
                    retStr="<option>\n"
            
            try: # erste version mediatypesTypes exists
                    for mediaType in self.mediaTypes:
                            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 patchContentType(self,obj=None):      def patchContentType(self,obj=None):
         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""          """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
Line 1751  class ECHO_root(Folder,Persistent,Implic Line 3069  class ECHO_root(Folder,Persistent,Implic
         return "changed all contenttypes in: "+self.title          return "changed all contenttypes in: "+self.title
   
   
       def repairAllCoords(self):
           """updates map coordinates on the same and sublevels"""
           return repairCoords(self)
   
   
     def patchViewClassification(self,obj=None):      def patchViewClassification(self,obj=None):
         """setze viewClassification heuristisch"""          """setze viewClassification heuristisch"""
   
     def checkIfArrow(obj):      def checkIfArrow(obj):
         if hasattr(obj,'coords'):          if hasattr(obj,'coords'):
             for coordtemp in obj.coords:              for coordtemp in obj.coords:
                 #print obj.title,len(coordtemp)  
                 if (len(coordtemp)>4) and not (coordtemp[4]==''):                  if (len(coordtemp)>4) and not (coordtemp[4]==''):
                     return 4                      return 4
             return None              return None
Line 1783  class ECHO_root(Folder,Persistent,Implic Line 3106  class ECHO_root(Folder,Persistent,Implic
                                   
         return "changed all contenttypes in: "+self.title          return "changed all contenttypes in: "+self.title
   
       def deleteCache(self,obj=None,RESPONSE=None):
           """setze alle collections auf cache = CacheManager"""
           if not obj:
               obj = self
           entries=obj.ZopeFind(obj,search_sub=1)
           for entry in entries:
                   if hasattr(entry[1],'_v_hash'):
                           entry[1]._v_hash=None
           
           return "changed all CM in: "+self.title
   
       
       security.declarePublic('ECHO_newViewerLink')
     def ECHO_newViewerLink(self,obj=None):      def ECHO_newViewerLink(self,obj=None):
         """change links (:86 faellt weg)"""          """change links (:86 faellt weg)"""
   
Line 1829  class ECHO_root(Folder,Persistent,Implic Line 3165  class ECHO_root(Folder,Persistent,Implic
                           
             for word in words:              for word in words:
                 strUrl=url%word                  strUrl=url%word
                 #print "str",strUrl  
                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)                  retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
             str=retStr              str=retStr
         if str:          if str:
Line 1837  class ECHO_root(Folder,Persistent,Implic Line 3173  class ECHO_root(Folder,Persistent,Implic
         else:          else:
             return ""              return ""
                   
     def link2html(self,str):      link2html=vlp_xmlhelpers.link2html
         """link2html fuer VLP muss hier noch raus"""  
         if str:  
             #print str  
             str=re.sub("\&","&amp;",str)  
             dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")  
             links=dom.getElementsByTagName("link")  
               
             #print "link",links  
             for link in links:  
                 link.tagName="a"  
                 ref=link.getAttribute("ref")  
                 if self.checkRef(ref):  
                     link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)  
   
             return dom.toxml('utf-8')  
         return ""  
   
       xml2html=vlp_xmlhelpers.xml2html
   
     def checkRef(self,ref):      checkRef=vlp_xmlhelpers.checkRef
         dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}  
         res=None  
         for db in dbs.keys():  
             #print ref,"select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])  
   
             res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))  #    def checkRef(self,ref):
         return res  #            if ref[0:3]=='lit':
                                       #                    if len(self.library_data({ 'id':ref}))>0:
     #Ende Methode fuer vlp  #                            return 1
   #            try:
   #                    if ref[0:7]=="tec_cat":
   #                            return 1
   #            except:
   #                    """nothing"""
   #                    
   #            dbs={'vl_technology':'','vl_people':" AND complete='yes'",'vl_sites':''}
   #            res=None
   #            for db in dbs.keys():
   #                    res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
   #            return res
   #                                    
   #    #Ende Methode fuer vlp
   
     def PgQuoteString(self,string):      def PgQuoteString(self,string):
         """Quote string"""          """Quote string"""
         #print "PG",string  
         return libpq.PgQuoteString(string)          return libpq.PgQuoteString(string)
                   
       security.declareProtected('View','getPartners')
     def getPartners(self):      def getPartners(self):
         """Get list of Partners. Presently only from a subfolder partners"""          """Get list of Partners. Presently only from a subfolder partners"""
                               if hasattr(self,'partners'):            
         return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]          return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
           else:
                   return []
                                   
       def getInstitutions(self):
           """Get list of Partners. Presently only from a subfolder partners"""
                                   
                              return [ item[1] for item in self.institutions.ZopeFind(self.institutions,obj_metatypes=['ECHO_institution'])]
   
           
     def getPartnersXML(self):      def getPartnersXML(self):
Line 1888  class ECHO_root(Folder,Persistent,Implic Line 3223  class ECHO_root(Folder,Persistent,Implic
     <partners>"""      <partners>"""
                   
     for partner in partners:      for partner in partners:
             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),unicode(partner.title,'utf-8','replace'))              ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)
   
         return ret+"\n</partners>"          return ret+"\n</partners>"
           
Line 1987  class ECHO_root(Folder,Persistent,Implic Line 3322  class ECHO_root(Folder,Persistent,Implic
                 else:                  else:
                     ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))                      ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
         ret +="""\n</index>"""          ret +="""\n</index>"""
         print ret              
                   
         self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")          self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
         self.REQUEST.RESPONSE.write(ret)          self.REQUEST.RESPONSE.write(ret)
                   
   
       def getMetaDatasXML(self,viewerType=None,filter=None):
               """gebe all ressourcen aus"""
               # check if the request's host part was OK
               http_host = self.REQUEST['HTTP_HOST']
               host_port = self.REQUEST['SERVER_PORT']
               fix_host = None
               if http_host and http_host.rfind(host_port) == -1:
                       print "HTTP_HOST needs fixing!"
                       fix_host = http_host + ":" + host_port
   
               ret="""<?xml version="1.0" ?>
                        <index>"""
               for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
   
                       echo_url=resource[1].absolute_url()
                       if fix_host:
                               #print "replacing ", http_host, " by ", fix_host
                               echo_url = string.replace(echo_url, http_host, fix_host, 1)
                       
                       if hasattr(resource[1],'link'):
                               meta_url=echo_url+"/getMetaDataXML"
                       else:
                               meta_url="NO_URL"
                               
                       if filter and not re.search(filter,viewer_url):
                               continue
   
                       #modificationDate=time.strptime(str(resource[1].bobobase_modification_time()),"%Y/%m/%d %H:%M:%S %Z")
                       
                       modificationDate=resource[1].bobobase_modification_time().strftime("%Y/%m/%d %H:%M:%S")
   
                       ret+="""\n<resource resourceLink="%s" metaLink="%s" modificationDate="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(meta_url,safe='/:?'),modificationDate)
                       
                               
               ret +="""\n</index>"""
   
               self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
               self.REQUEST.RESPONSE.write(ret)
   
               
       def findPartners(self):     
           """find all partners in partners"""
           par=self.ZopeFind(self.partners, obj_metatypes='ECHO_partner')
           return par
           
       def getPartnerFromID(self):
           """find partner form ID return object"""
           pa=self.REQUEST['partner']
           par=self.ZopeFind(self.partners, obj_ids=[pa])
           return par
           
       def getPartnerFromIDParameter(self, id):
           """ find partners from ID"""
           par=self.ZopeFind(self.partners, obj_ids=[id])
           return par
           
       def getInstitutionFromID(self,id):
           """ find institution from id """
           inst=self.ZopeFind(self.institutions, obj_ids=[id])
           return inst
   
           
 def manage_addECHO_root(self,id,title,RESPONSE=None):  def manage_addECHO_root(self,id,title,RESPONSE=None):
     """Add an ECHO_root"""      """Add an ECHO_root"""
     self._setObject(id,ECHO_root(id,title))      self._setObject(id,ECHO_root(id,title))
Line 2001  def manage_addECHO_root(self,id,title,RE Line 3399  def manage_addECHO_root(self,id,title,RE
   
 def manage_addECHO_rootForm(self):  def manage_addECHO_rootForm(self):
         """Nothing yet"""          """Nothing yet"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)          pt=zptFile(self, 'zpt/AddECHO_root.zpt')
           return pt()
   
   class ECHO_copyrightType(Folder,ECHO_basis):
           """copyright typ"""
   
           meta_type="ECHO_copyrightType"
           
           def __init__(self,id,title,label,url):
                   """init"""
                   self.id=id
                   self.title=title
                   self.label=label
                   self.url=url
   
           manage_options = Folder.manage_options+(
           {'label':'Main Config','action':'ECHO_copyrightType_config_mainForm'},
           )
   
           def ECHO_copyrightType_config_mainForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_copyrightType')
                   pt.content_type="text/html"
                   return pt()
   
           def ECHO_copyrightType_config_main(self,title,label,url,RESPONSE=None):
                   """change"""
                   self.title=title
                   self.label=label
                   self.url=url
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
   def manage_addECHO_copyrightTypeForm(self):
           """Form for adding a ressource"""
           pt=zptFile(self, 'zpt/AddECHO_copyrightTypeForm.zpt')
         return pt()          return pt()
     
 class ECHO_partner(Image,Persistent):  
   def manage_addECHO_copyrightType(self,id,title,label,url,RESPONSE=None):
       """addaresource"""
   
       newObj=ECHO_copyrightType(id,title,label,url)
   
       self._setObject(id,newObj)
   
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
    
   
    
   class ECHO_partner(Image,Persistent,ECHO_basis):
     """ECHO Partner"""      """ECHO Partner"""
   
     meta_type="ECHO_partner"      meta_type="ECHO_partner"
   
     def __init__(self, id, title,url, file, 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.email=email
           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)
Line 2023  class ECHO_partner(Image,Persistent): Line 3474  class ECHO_partner(Image,Persistent):
         {'label':'Partner Information','action':'ECHO_partner_config'},          {'label':'Partner Information','action':'ECHO_partner_config'},
         )          )
   
     def changeECHO_partner(self,url,RESPONSE=None):      
       def changeECHO_partner(self,url,copyrightType,person, email, country, color, RESPONSE=None):
         """Change main information"""          """Change main information"""
         self.url=url          self.url=url
           self.person=person
           self.email=email
           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')
                           
Line 2035  class ECHO_partner(Image,Persistent): Line 3492  class ECHO_partner(Image,Persistent):
         """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_partner.zpt')
         return pt()          return pt()
   
                   
Line 2044  manage_addECHO_partnerForm=DTMLFile('dtm Line 3501  manage_addECHO_partnerForm=DTMLFile('dtm
   
   
   
 def manage_addECHO_partner(self, id, file,url, title='', precondition='', content_type='',  def manage_addECHO_partner(self, id, url, person, email, country, color, file=None, copyrightType='', title='', precondition='', content_type='',
                     REQUEST=None):                      REQUEST=None):
     """      """
     Add a new ECHO_partner object.      Add a new ECHO_partner object.
Line 2063  def manage_addECHO_partner(self, id, fil Line 3520  def manage_addECHO_partner(self, id, fil
     self=self.this()      self=self.this()
   
     # First, we create the image without data:      # First, we create the image without data:
     self._setObject(id, ECHO_partner(id,title,url,'',content_type, precondition))      self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, color, 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 2078  def manage_addECHO_partner(self, id, fil Line 3535  def manage_addECHO_partner(self, id, fil
         REQUEST.RESPONSE.redirect('%s/manage_main' % url)          REQUEST.RESPONSE.redirect('%s/manage_main' % url)
     return id      return id
   
   class ECHO_linkList(ZopePageTemplate,ECHO_basis):
       """LinkList Objekt"""
       meta_type="ECHO_linkList"
   
       _default_content_fn = os.path.join(package_home(globals()), 'html/ECHO_pageTemplateDefault.html')
   
       manage_options = ZopePageTemplate.manage_options+(
           {'label':'Main Config','action':'changeECHO_linkListWeightForm'},
           )
   
       def content_html(self):
           """content_html"""
           return ECHO_basis.content_html(self,'pageTemplate')
   
       def changeECHO_linkListWeightForm(self):
           """change"""
           pt=zptFile(self, 'zpt/ChangeECHO_linkListTemplate.zpt')
           return pt()
   
       def changeECHO_linkListWeight(self,contentType,label,RESPONSE=None):
           """change"""
           self.contentType=contentType
           self.label=label
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def getLabel(self):
           if hasattr(self,'label'):
               return self.label.encode('utf-8')
           else:
               return 0
           
       def getcontentType(self):
           """get contentType"""
           if hasattr(self,'contentType'):
               return self.contentType
           else:
               return 0
   
       def __init__(self, id, label, title=None, text=None, contentType=None):
            self.id = str(id)
            self.title=title
            self.label=label
            self.ZBindings_edit(self._default_bindings)
            if text is None:
                text = ''
            self.pt_edit(text, contentType)
   
   
   
   
   def manage_addECHO_linkListForm(self):
       """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_linkListTemplate.zpt')
       return pt()
   
   
   def manage_addECHO_linkList(self, id, label,contentType=0,title=None, text=None,
                              REQUEST=None, submit=None):
       """Add a LinkList with optional file content."""
       
       id = str(id)
       if REQUEST is None:
           self._setObject(id, ECHO_linkList(id, label, text))
           ob = getattr(self, id)
           setattr(ob,'contentType',contentType)
           if title:
               ob.pt_setTitle(title)
           return ob
       else:
           file = REQUEST.form.get('file')
           headers = getattr(file, 'headers', None) 
           if (headers is None) or (not file.filename):
               zpt = ECHO_linkList(id, file)
           else:
               zpt = ECHO_linkList(id, label,'', file, headers.get('contentType'))
   
           self._setObject(id, zpt)
           ob = getattr(self, id)
           if title:
               ob.pt_setTitle(title)
           
           try:
               u = self.DestinationURL()
           except AttributeError:
               u = REQUEST['URL1']
   
           if submit == " Add and Edit ":
               u = "%s/%s" % (u, urllib.quote(id))
           REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
       
   
   class ECHO_support(Folder,ECHO_basis):
           """gefoerdert durch"""
           meta_type="ECHO_support"
           
           
           
           def __init__(self,id,institutions=None):
                   """init"""
                   self.id=id
                   self.title=''
                   self.institutions=toList(institutions)
   
           def getSupporter(self):
                   """return institutions"""
                   if self.institutions:
                           return self.institutions
                   else:
                           return []
                   
           manage_options = Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_support_configForm'},
                   )
   
           def ECHO_support_configForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_support')
                   pt.content_type="text/html"
                   return pt()
   
           def ECHO_support_config(self,institutions=None,RESPONSE=None):
                   """change"""
                   self.institutions=toList(institutions)
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
                   
   def manage_addECHO_supportForm(self):
       """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_support.zpt')
       return pt()
   
   def manage_addECHO_support(self, id,institutions=None,RESPONSE=None):
           """add the copyright"""
   
           meta_type="ECHO_support"
           
           
           self._setObject(id, ECHO_support(id,institutions))
   
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
                   
   
   class ECHO_institution(Image,Persistent,ECHO_basis):
       """ECHO Institution"""
   
       meta_type="ECHO_institution"
   
       def __init__(self, id, title,url, file, person, email, country, content_type='', precondition=''):
           self.__name__=id
           self.title=title
           self.url=url
           self.person=person
           self.email=email
           self.country=country
           self.precondition=precondition
           data, size = self._read_data(file)
           content_type=self._get_content_type(file, data, id, content_type)
           self.update_data(data, content_type, size)
   
       manage_options = Image.manage_options+(
           {'label':'Institution Information','action':'ECHO_institution_config'},
           )
   
       
       def changeECHO_institution(self,url,person, email, country,RESPONSE=None):
           """Change main information"""
           self.url=url
           self.person=person
           self.email=email
           self.country=country
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
               
               
   
       def ECHO_institution_config(self):
           """Main configuration"""
           if not hasattr(self,'url'):
               self.url=""
           pt=zptFile(self, 'zpt/ChangeECHO_institution.zpt')
           return pt()
   
           
   manage_addECHO_institutionForm=DTMLFile('dtml/ECHO_institutionAdd',globals(),
                                Kind='ECHO_institution',kind='ECHO_institution')
   
   
   
   def manage_addECHO_institution(self, id, url, person, email, country, file=None, title='', precondition='', content_type='',
                       REQUEST=None):
       """
       Add a new ECHO_institution object.
   
       Creates a new ECHO_institution object 'id' with the contents of 'file'.
       Based on Image.manage_addImage
       """
   
       id=str(id)
       title=str(title)
       content_type=str(content_type)
       precondition=str(precondition)
   
       id, title = OFS.Image.cookId(id, title, file)
   
       self=self.this()
   
       # First, we create the image without data:
       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
       # can use a database trick to make the upload more efficient.
       if file:
           self._getOb(id).manage_upload(file)
       if content_type:
           self._getOb(id).content_type=content_type
   
       if REQUEST is not None:
           try:    url=self.DestinationURL()
           except: url=REQUEST['URL1']
           REQUEST.RESPONSE.redirect('%s/manage_main' % url)
       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
Removed from v.1.89  
changed lines
  Added in v.1.241

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