[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.42 and 1.212

version 1.42, 2004/04/16 10:12:15 version 1.212, 2005/02/10 16:17:52
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
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 from AccessControl import ClassSecurityInfo  from AccessControl import ClassSecurityInfo
   from AccessControl.User import UserFolder
 from Globals import InitializeClass  from Globals import InitializeClass
 from Globals import DTMLFile  from Globals import DTMLFile
   import Globals
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Globals import Persistent, package_home  from Globals import Persistent, package_home
 from Acquisition import Implicit  from Acquisition import Implicit
   
 #from psycopg import libpq  
 #from pyPgSQL import libpq  
 import xml.dom.minidom  
   
 import urllib  import urllib
 import xml.dom.minidom  import smtplib
 from ECHO_graphicalOverview import javaHandler,javaScriptMain  import time
 import ECHO_helpers  from Ft.Xml.Domlette import NonvalidatingReader
   from Ft.Xml.Domlette import PrettyPrint
 #List of different types for the graphical linking viewer  from Ft.Xml import EMPTY_NAMESPACE
 viewClassificationListMaster=['view point','area']  
   import Ft.Xml.XPath
 def content_html(self,type):  import cStringIO
         """template fuer content"""  import zLOG
         #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])  
         #  
         #if templates:  
         #    return templates[0][1]()  
   
         try:  
             obj=getattr(self,type+"_template")  
             return obj()  
         except:  
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)  
             pt.content_type="text/html"  
             return pt()  
       
 def toList(field):  
     """Einzelfeld in Liste umwandeln"""  
     if type(field)==StringType:  
         return [field]  
     else:  
         return field  
       
 def getText(nodelist):  
   
     rc = ""  
     for node in nodelist:  
         if node.nodeType == node.TEXT_NODE:  
            rc = rc + node.data  
     return rc  
   
   
 def readMetadata(url):  
     """Methoden zum Auslesen der Metadateninformation zu einer Resource  
     Vorerst noch Typ bib"""  
       
     metadict={}  
     try:      try:
         geturl=""      from psycopg import libpq
         for line in urllib.urlopen(url).readlines():  
             geturl=geturl+line  
           
           
     except:      except:
         return (None,"Cannot open: "+url)  
   
     try:      try:
         dom=xml.dom.minidom.parseString(geturl)          from pyPgSQL import libpq
     except:      except:
         return (None,"Cannot parse: "+url+"<br>"+geturl)          print "ECHO_collection: Warning - No libpq imported!"
   
     metanode=dom.getElementsByTagName('bib')  import xml.dom.minidom
     metadict['bib_type']='Book'  
     if len(metanode)==0:  
         metanode=dom.getElementsByTagName('archimedes')  
         metadict['bib_type']='Archimedes'  
         #print "HELLO"  
                   
     if not len(metanode)==0:      import urllib
         metacontent=metanode[0].childNodes  import xml.dom.minidom
   import ECHO_helpers
   from ECHO_helpers import *
   from ECHO_language import *
           
         try:  
             metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)  
         except:  
             """nothing"""  
                   
         for node in metacontent:  #regexp for extracting elements from xml
             try:  patternTXT=r"<\s*txt.*?>(.*?)</txt>"
                 metadict[node.tagName.lower()]=getText(node.childNodes)  regexpTXT = re.compile(patternTXT, re.IGNORECASE + re.DOTALL)
             except:  patternPage=r"<\s*page.*?>(.*?)</page>"
                 """nothing"""  regexpPage = re.compile(patternPage, re.IGNORECASE + re.DOTALL)
   
     #print metadict  
     return metadict,""  
           
   
 def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):  def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs=""):
   
         """Allegemeine Informationen zu einer ECHO Collection"""          """Allegemeine Informationen zu einer ECHO Collection"""
   
         self.viewClassification=viewClassification  
   
         self.label = label          self.label = label
         self.title=title          self.title=title
         self.description=description          self.description=description
Line 128  def setECHO_collectionInformation(self,t Line 86  def setECHO_collectionInformation(self,t
         self.credits=toList(credits)          self.credits=toList(credits)
         self.weight=weight          self.weight=weight
   
         coords=[]  
         #coordinates of for rectangles  
   
         #print "cs", coordstrs  class ECHO_copyright(Folder,ECHO_basis):
         if coordstrs:      """Copyright informationen"""
             for coordstr in coordstrs:      meta_type="ECHO_copyright"
                 #print "cs", coordstr      
                 try:  
                     temco=coordstr.split(",")  
                 except:  
                     temco=[]  
                 #temco.append(angle)  
                 coords.append(temco)  
   
   
         self.coords=coords[0:]      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
   
 class scientificClassification(SimpleItem,Persistent,Implicit):      manage_options = Folder.manage_options+(
     """outdated will be deleeted in the next versions: subclass"""          {'label':'Main Config','action':'ECHO_copyright_configForm'},
     security=ClassSecurityInfo()          )
           
     def __init__(self,context,science,practice):  
         self.context=context  
         self.science=science  
         self.practice=practice  
         self.id="scientific_Classification"  
           
     security.declarePublic('get_context')  
     def get_context(self):  
         return self.context  
       
     security.declarePublic('get_science')  
     def get_science(self):  
         return self.science  
           
     security.declarePublic('get_practice')  
     def get_practice(self):  
         return self.practice  
           
       def ECHO_copyright_configForm(self):
           """change form"""
           pt=zptFile(self, 'zpt/ChangeECHO_copyright')
           pt.content_type="text/html"
           return pt()
   
       def ECHO_copyright_config(self,title,RESPONSE=None):
           """change"""
           self.title=title
           self.copyrights=[]
           self.copyrights=getCopyrightsFromForm(self,self.REQUEST.form)[0:]
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
                                   
 class scientificInformation(Folder,Persistent,Implicit):  
     """outdated will be deleted in the next versions: subclass scientificInformation"""  
     security=ClassSecurityInfo()  
           
   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"""
           
     def __init__(self,source_type,period):      meta_type="ECHO_copyright"
   
         self.id="scientific_Information"      #first generate copyrights as list of tripels (mediaType,partner,copyrightType)
         self.source_type=source_type  
         self.period=period  
                   
   
   
     security.declarePublic('get_source_type')      self._setObject(id, ECHO_copyright(id, title,getCopyrightsFromForm(self,self.REQUEST.form)))
     def get_source_type(self):  
         return self.source_type  
           
     security.declarePublic('get_period')      if RESPONSE is not None:
     def get_period(self):          RESPONSE.redirect('manage_main')
         return self.period  
   
 class ECHO_layoutTemplate(ZopePageTemplate):  class ECHO_layoutTemplate(ZopePageTemplate,ECHO_basis):
     """Create a layout Template for different purposes"""      """Create a layout Template for different purposes"""
   
     meta_type="ECHO_layoutTemplate"      meta_type="ECHO_layoutTemplate"
Line 199  class ECHO_layoutTemplate(ZopePageTempla Line 151  class ECHO_layoutTemplate(ZopePageTempla
     def __init__(self, id, text=None, content_type=None,EchoType=None):      def __init__(self, id, text=None, content_type=None,EchoType=None):
         self.id = str(id)          self.id = str(id)
   
   
   
         self.ZBindings_edit(self._default_bindings)          self.ZBindings_edit(self._default_bindings)
         if text is None:          if text is None:
             self._default_content_fn = os.path.join(package_home(globals()),              self._default_content_fn = os.path.join(package_home(globals()),'zpt','ECHO_%s_template_standard.zpt'%EchoType)
                                                'zpt/ECHO_%s_template_standard.zpt'%EchoType)  
             text = open(self._default_content_fn).read()              text = open(self._default_content_fn).read()
         self.pt_edit(text, content_type)          self.pt_edit(text, content_type)
   
           
         """change form"""  
   
   
 def manage_addECHO_layoutTemplateForm(self):  def manage_addECHO_layoutTemplateForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_layoutTemplate.zpt').__of__(self)      pt=zptFile(self, 'zpt/AddECHO_layoutTemplate.zpt')
     return pt()      return pt()
   
 from urllib import quote  
   
   
 def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):  def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
     "Add a Page Template with optional file content."      "Add a Page Template with optional file content."
Line 259  def manage_addECHO_layoutTemplate(self, Line 203  def manage_addECHO_layoutTemplate(self,
     REQUEST.RESPONSE.redirect(u+'/manage_main')      REQUEST.RESPONSE.redirect(u+'/manage_main')
     return ''      return ''
   
 class ECHO_resource(Folder):  class ECHO_fullText(ZopePageTemplate,ECHO_basis,ECHO_language):
       """echo fulltext in xml"""
   
       meta_type="ECHO_fullText"
   
       
       def getPage(self,nr='1'):
           """get page n"""
           dom=xml.dom.minidom.parseString(self())
           pages=dom.getElementsByTagName('page')
           
           return pages[int(nr)-1].toxml('utf-8')
       
   # 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(Folder,Persistent,ECHO_basis):
     """ECHO Ressource"""      """ECHO Ressource"""
       security=ClassSecurityInfo()
     meta_type='ECHO_resource'      meta_type='ECHO_resource'
   
     viewClassificationList=viewClassificationListMaster  #    viewClassificationList=viewClassificationListMaster
   
     getSubCols = ECHO_helpers.getSubCols      getSubCols = ECHO_helpers.getSubCols
   
       security.declareProtected('View','index_html')
   
       
     
       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
           
   
           tempdir="/tmp/archivesImageServer"
           if not os.path.exists(tempdir):
               os.mkdir(tempdir) 
     
           tmpPath=tempfile.mkdtemp(dir=tempdir)
           
   
           tmpZip=tempfile.mktemp(dir=tempdir)
   
           tmpFn=os.path.split(tmpZip)[1]
   
   
       
   
           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")
   
           if RESPONSE:
               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:
               geturl=""
               for line in ECHO_helpers.urlopen(url).readlines():
                   geturl=geturl+line
   
   
           except:
               return (None,"Cannot open: "+url)
   
           try:
               dom=xml.dom.minidom.parseString(geturl)
               root=dom.getElementsByTagName('resource')[0]
           except:
               return (None,"Cannot parse: "+url+"<br>"+geturl)
   
           internal=dom.getElementsByTagName('internal')
           if internal:
               institution=dom.getElementsByTagName('institution')
               return getText(institution[0].childNodes)
           
           free=dom.getElementsByTagName('free')
           if free:
               return "free"
   
           return "free" #default free
   
       def changeAccessRightMD(self,accessright,RESPONSE=None):
           """change the rights"""
           
           params="accessright=%s"%accessright
   
   
           #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).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()+'/setAccessRightXML'+urllib.quote('?'+params))).read()
   
         
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
           
       def setAccessRightXML(self,accessright):
           """set accessright"""
           url=self.metalink
   
           try:
               geturl=""
               for line in ECHO_helpers.urlopen(url).readlines():
                   geturl=geturl+line 
   
   
           except:
               return (None,"Cannot open: "+url)
   
           try:
               dom=xml.dom.minidom.parseString(geturl)
               root=dom.getElementsByTagName('resource')[0]
           except:
               return (None,"Cannot parse: "+url+"<br>"+geturl)
   
           metanodes=dom.getElementsByTagName('access-conditions')
   
           if not metanodes:
               nodenew=dom.createElement('access-conditions')
               root.appendChild(nodenew)
               metanode=nodenew
           else:
               metanode=metanodes[0]
   
           accesses=metanode.getElementsByTagName('access')
   
           if not accesses:
               nodenew2=dom.createElement('access')
               metanode.appendChild(nodenew2)
               metanode2=nodenew2
           else:
               metanode2=accesses[0]
   
           internal=metanode.getElementsByTagName('internal')
   
           if internal:
               metanode2.removeChild(internal[0]).unlink()
   
           free=metanode.getElementsByTagName('free')
           
           if free:
               metanode2.removeChild(internal[0]).unlink()
   
   
           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)
   
           return dom.toxml().encode('utf-8')
   
       def setStartPageForm(self):
           """Form for changing the startpage"""
   
           
           pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPage.zpt')
               pt.content_type="text/html"
               return pt()
       
   
       def createImageUrl(self,pn=1):
           """create ImageUrl"""
   
           
           resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
           
           digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')
           images=readFieldFromXML(self.metalink,'texttool','image')
   
   
           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
   
           return "%sfn=%s&pn=%i"%(digiliburlprefix,resourcepath+"/"+images,pn)
       
       def copyTitleToInfoXML(self,RESPONSE=None):
           """copy title from the resource"""
           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()
   
           
       def setStartPage(self,startpage=None,RESPONSE=None):
           """set start page, if no startpage defined use the generic one of the resource"""
   
           if (not (type(startpage)==StringType)):
               if ("__generic" in startpage): # checke ob generic in der liste
                   startpage=self.absolute_url()+"/startpage_html"
               elif ("__firstPage" in startpage): # checke ob generic in der liste
                   startpage=self.createImageUrl()
                   
           if (not startpage):
               startpage=self.absolute_url()+"/startpage_html"
           elif (startpage=="__generic"):
               startpage=self.absolute_url()+"/startpage_html"
           elif (startpage=="__firstPage"):
                   startpage=self.createImageUrl()
       
           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))
                                                                    
           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()
       
           
           path=self.metalink
           
           path=re.sub(self.REQUEST['SERVER_URL'],'',path)
           path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
           
           path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
           path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
           path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
               path=re.sub('http://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) 
   
   
           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')
   
       def changeViewerTemplateSetForm(self):
           """change the viewer template set"""
           pt=zptFile(self, 'zpt/changeResourceViewerTemplateSet')
               return pt()
   
   
      
       def getTextToolsField(self,name,default=''):
           """Lese Textoolsfelder aus index.meta im path aus"""
           
           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:
                   return getText(subnode.childNodes)
           except:
               return default
      
   
       def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
           """changeit"""
   
           paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate','digiliburlprefix']
   
           
           #writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)
   
           params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
   
           
           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()
   
           #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)
           # hack Pfad auf die Dokumente
           path=self.metalink
           
           
   
           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:
   #            return ""
   
       def getFullTextXML(self,noredirect=None):
           """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
   
           try:
               #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)
               texttools=dom.getElementsByTagName('texttool')
               text=texttools[0].getElementsByTagName('text')
               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:
                   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)
         else:          else:
             return ""                  return texturl
           except:
   
               if not noredirect:
                   self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
                   self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
               else:
                   return "<error>no fulltext available</error>"
   
       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 284  class ECHO_resource(Folder): Line 791  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 297  class ECHO_resource(Folder): Line 806  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 305  class ECHO_resource(Folder): Line 817  class ECHO_resource(Folder):
             coordsnew=[]              coordsnew=[]
                   
         self.coords=coordsnew          self.coords=coordsnew
   #   self.viewClassification=""
   
   
     def getCoords(self):  
       def getContentType(self):
         try:          try:
             return [string.join(x,",") for x in self.coords]                return self.contentType
         except:          except:
             return []              return ""
   
       def getCopyrightType(self):
           try:
               return self.copyrightType
           except:
               return ""
   
       def getRenderingType(self):
           try:
               return self.renderingType
           except:
               return ""
   
     def ECHO_resource_config(self):      def ECHO_resource_config(self):
         """Main configuration"""          """Main configuration"""
   
         if not hasattr(self,'weight'):          if not hasattr(self,'weight'):
             self.weight=""              self.weight=""
         if not hasattr(self,'coords'):  
             self.coords=[]  
   
         print "vorher",self.coords          pt=zptFile(self, 'zpt/ChangeECHO_resource.zpt')
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)          return pt()
       
   
       def ECHO_resource_config_main(self):
           """Main configuration"""
           if not hasattr(self,'weight'):
               self.weight=""
           pt=zptFile(self, 'zpt/ChangeECHO_resource_main.zpt')
           return pt()
   
       def ECHO_resource_config_coords(self):
           """Coords configuration """
           pt=zptFile(self, 'zpt/ChangeECHO_resource_coords.zpt')
           return pt()
   
       def ECHO_resource_config_credits(self):
           """Main configuration"""
           pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')
           return pt()
   
       def ECHO_resource_config_metadata(self):
           """Main configuration"""
       if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
           self.metaDataHash={}
           self.contentType=self.bib_type
           for data in self.metadata:
               data_neu=re.sub('-','_',data)
               self.meta
                           DataHash[data_neu]=getattr(self,data)[0:]
   
       
           pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')
         return pt()          return pt()
           
   
     def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):  
         """Änderung der Properties"""  
                   
   
       def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):
           """Aenderung der Properties"""
       self.resourceID=resourceID
       self.title=title
       self.label=label
       self.description=description
   
       self.contentType=contentType
       self.renderingType=renderingType
       self.weight=weight
       
           self.link=link
           self.metalink=metalink
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
       def changeECHO_resource_coords(self,RESPONSE=None):
           """Aenderung der Properties - coords"""
       #return self.REQUEST
       for area in self.getMapAreas():
           id = area.getId()
           if self.REQUEST.has_key('del.'+id):
           # delete this area
           self._delObject(id)
           # return to same menu
           if RESPONSE is not None:
               RESPONSE.redirect('ECHO_resource_config_coords')
           return
           # 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:
           RESPONSE.redirect('manage_main')
   
   
       def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
           """Aenderung der Properties"""
       self.credits=credits
       self.responsible=responsible
       self.copyrightType=copyrightType
           
           if RESPONSE is not None:
               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):
           """change metadata"""
           tags=self.findTagsFromMapping(self.contentType)
           self.OSAS_meta={}
           for field in tags[1]:
     try:              try:        
             coordsnew=[ string.split(x,",") for x in coords]                  self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
                   self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
         except:          except:
         coordsnew=[]                      """nothing"""
   
           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:
               RESPONSE.redirect('manage_main')
   
   
       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"""
           self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
   
           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 showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
           """schreibe md"""
           
           try:
               
               return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
           except:
               return "<error> no metadata stored</error>"
                   
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)      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)
   
         self.coords=coordsnew[0:]      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 346  class ECHO_resource(Folder): Line 1011  class ECHO_resource(Folder):
                           
                           
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Main Config','action':'ECHO_resource_config'},          {'label':'Main Config','action':'ECHO_resource_config_main'},
         {'label':'Metadata','action':'ECHO_getResourceMD'},      {'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
         {'label':'Graphics','action':'ECHO_graphicEntry'},      {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
           {'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 isDefinedInThisSet(self,fields,field):
           """checks if field is defined in fields"""
           if (fields[0].has_key(field)) and not (fields[0][field]==""):
               return 1
           else:
   
     def ECHO_graphicEntry(self):              return 0
         """DO nothing"""          
         overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])      def getFieldLabel(self,fields,field):
         if overview:           """get labels"""
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)          try:
             return pt()              ret =fields[0][field]
               if ret == "":
                   return field
         else:          else:
             return "NO OVERVIEW GRAPHICS"                  return ret
           except:
               return field
   
     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:      def getFieldTag(self,fields,field):
             RESPONSE.redirect('ECHO_graphicEntry')          """get labels"""
           try:
               ret =fields[0][field]
               if ret == "":
                   return field
               else:
                   return ret
           except:
               return field
   
       
           
       def getFieldValue(self,field):
           """get value"""
       
           try:
       
               ret=self.metaDataHash[field]
               if ret == "":
                   return None
               else:
               
               return ret
           except:
               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):
           """gib hash mit label -> generic zurueck"""
       #return {},[]
   
           temp=self.ZopeFind(self.standardMD)
   
       if referenceType=="":
           referenceType="book"
       
       
           bibdata={}
           retdata={}
       fields=[]
           fieldlist=self.standardMD.fieldList
   
           tags=self.findTagsFromMapping(self.contentType)
       self.referencetypes=tags[2]
       for referenceTypeF in self.referencetypes:
   
           if referenceTypeF[1].title.lower() == referenceType.lower():
   
               try:
                   bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
                   referenceType=referenceTypeF[1].title
               except:
                   bibdata[referenceType]=referenceTypeF[1].fields
           
   
               bibdata['data']=referenceTypeF[1]
               fields=bibdata[referenceType]
                           for field in fieldlist:
                               retdata[field]=referenceTypeF[1].getValue(field)[1]
   
           return retdata,fieldlist,temp,fields
   
       def findTagsFromMapping(self,referenceType):
           """gib hash mit label -> generic zurueck"""
       
   
       if referenceType=="":
           referenceType="book"
       
       temp =  self.ZopeFind(self.standardMD)[0:]
   
       
       #self.referencetypes=temp[0:]
       
       
       
   
       
   
           bibdata={}
           retdata={}
           fieldlist=self.standardMD.fieldList
           fields=[]
       for referenceTypeF in temp:
           #print referenceType
       
           if referenceTypeF[1].title.lower() == referenceType.lower(): 
               try:
                   bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
                   referenceType=referenceTypeF[1].title
               except:
                   bibdata[referenceType]=referenceTypeF[1].fields
               bibdata['data']=referenceTypeF[1]
               fields=bibdata[referenceType]
                           for field in fieldlist:
                               retdata[field]=referenceTypeF[1].getValue(field)[0]
       
           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"""
   
     def ECHO_getResourceMD(self,template="yes"):  
         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""  
         (metadict, error)=readMetadata(self.metalink)          (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)
           
           #fields=self.findLabelsFromMapping(self.contentType)
           for field in fields[1]:
               
               if self.isDefinedInThisSet(fields,field):
                   #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))
                   self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))
   
           
           
           if RESPONSE:
               return RESPONSE.redirect('manage_main')
           
       def ECHO_getResourceMD(self,template="yes",back=None):
           """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
           (metadict, error)=readMetadata(self.metalink)
   
           if back:
               self.REQUEST.SESSION['back']=back
   
         if not error=="": #Fehler beim Auslesen des Metafiles          if not error=="": #Fehler beim Auslesen des Metafiles
             return "ERROR:",error              return "ERROR:",error
         for key in metadict.keys():#Hinzufügen der Felder  
   
             setattr(self,key,metadict[key].encode('ascii','replace'))  
                   
       if not (metadict['bib_type'].lower()==self.contentType.lower()):
           self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
           self.REQUEST.SESSION['contentZope']=self.contentType
   
           return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
   
       self.REQUEST.SESSION['metadict']=metadict
   
       
       
       self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])
   
         self.metadata=metadict.keys()  
   
         self.label=self.generate_label()  
                   
         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
           
           
     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"""      """addaresource"""
   
     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 431  def manage_addECHO_resource(self,id,titl Line 1315  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'
   
       security.declarePublic('content_html')
     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 464  class ECHO_externalLink(Folder): Line 1349  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 490  class ECHO_externalLink(Folder): Line 1368  class ECHO_externalLink(Folder):
         {'label':'Main Config','action':'ECHO_externalLink_config'},          {'label':'Main Config','action':'ECHO_externalLink_config'},
         )          )
   
     def getCredits(self):  
         """Ausgabe der credits"""  
         if self.credits:  
             return self.credits  
         else:  
             return []  
                   
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
Line 504  class ECHO_externalLink(Folder): Line 1376  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 519  def manage_addECHO_externalLink(self,id, Line 1391  def manage_addECHO_externalLink(self,id,
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
     
   
   class ECHO_link(ECHO_externalLink):
       """external_link"""
   
       meta_type="ECHO_link"
       
           
       def content_html(self):
           """template fuer link"""
           if hasattr(self,"link_template"):
               return ECHO_basis.content_html(self,'link')
           else:
               return ECHO_basis.content_html(self,'collection')
       
   def manage_addECHO_linkForm(self):
           """Form for external Links"""
           pt=zptFile(self, 'zpt/AddECHO_linkForm.zpt')
           return pt()
   
   
   def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
       """Add an external Link"""
   
       newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)
   
       self._setObject(id,newObj)
   
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
       
   
 class ECHO_collection(Folder, Persistent, Implicit):  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
       displayTypes=displayTypes
   
       path="/mpiwg/online/permanent/shipbuilding"
   
       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_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_resource'])
           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 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):
           """form"""
           pt=zptFile(self, 'zpt/createRessourcesFromXMLForm.zpt')
           return pt()
   
       def createRessourcesFromXML(self,fileupload):
           """read an XML file for generating resources"""
           dom=xml.dom.minidom.parse(fileupload)
           ret="<h2>Added</h2>"
           for resource in dom.getElementsByTagName('resource'):
               link=getText(resource.getElementsByTagName('link')[0].childNodes)
               label=getText(resource.getElementsByTagName('label')[0].childNodes)
               #splitted=link.split("?")[0].split("/")
               #id=splitted[len(splitted)-1].encode('ascii')
               id=re.sub(" ","_",label).encode('ascii')
               
               ret+="<p>"+label+"</p>"
               manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","")
           return ret
           
       security.declarePublic('getImageTag')
     def getImageTag(self):      def getImageTag(self):
         """GetTag"""          """GetTag"""
         try:          try:
Line 535  class ECHO_collection(Folder, Persistent Line 1776  class ECHO_collection(Folder, Persistent
     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 554  class ECHO_collection(Folder, Persistent Line 1795  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=\""+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" ?>"""
           return ret+"<collection>"+getCollection(self,pwstr=pwstr)+"</collection>"
   
         return "<collection>"+getCollection(self)+"</collection>"      def createAllJSAreas(self):
               """create area calls for JavaScript"""
     def createJavaScript(self):          areas = self.getAllMapAreas()
         """CreateJava"""      return self.createJSAreas(areas)
         ret=javaScriptMain  
   
         dynamical=""  
         for ob in self.getGraphicCoords():  
             dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])  
         ret+=javaHandler%dynamical  
         return ret  
           
     security.declarePublic('getCreditObject')      security.declarePublic('getCreditObject')
     def getCreditObject(self,name):      def getCreditObject(self,name):
Line 610  class ECHO_collection(Folder, Persistent Line 1854  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):  
         """Rerender all Links"""  
           
         for entry in self.__dict__.keys():  
             object=getattr(self,entry)  
               
               
             try:  
                   
                 if object.meta_type == 'ECHO_resource':  
                       
                     object.ECHO_getResourceMD(template="no")  
                       
             except:  
                 """nothing"""  
                   
         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]    
             return x  
   
         except:      security.declarePublic('ECHO_rerenderLinksMD')
       def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
           """Rerender all Links"""
       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 663  class ECHO_collection(Folder, Persistent Line 1889  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':'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':'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 709  class ECHO_collection(Folder, Persistent Line 1915  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 726  class ECHO_collection(Folder, Persistent Line 1926  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=""):          
         """Änderung der Properties"""      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):
           """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.location=location
       self.isAlwaysClickable=isAlwaysClickable
           
         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)  
   
         self.coords=coordsnew[0:] # HACK fehler in setECHO_collection  
                   
         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')
           
     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'):
                   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_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
           return ECHO_basis.content_html(self,'collection')
           
     def getCredits(self):      def getCredits(self):
         """Ausgabe der credits"""          """Ausgabe der credits"""
Line 787  class ECHO_collection(Folder, Persistent Line 2003  class ECHO_collection(Folder, Persistent
         else:          else:
             return []              return []
   
       def area_img(self):
           """area image"""
       bt = BrowserCheck(self)
       if bt.isIE or bt.isN4:
           return sendFile(self, 'images/red.gif', 'image/gif')
       else:
           return sendFile(self, 'images/reda.png', 'image/png')
   
       def trans_img(self):
           """empty image"""
           return sendFile(self, 'images/trans.gif', 'image/gif')
   
       def hl_lib_js(self):
           """javascript"""
           return sendFile(self, 'js/hl_lib.js', 'text/plain')
   
       def js_lib_js(self):
           """javascript -- old name"""
           return sendFile(self, 'js/baselib.js', 'text/plain')
   
       def baselib_js(self):
           """javascript"""
           return sendFile(self, 'js/baselib.js', 'text/plain')
   
       def hl_add_js(self):
           """javascript"""
           return sendFile(self, 'js/hl_add.js', 'text/plain')
   
               def getAllMapAreas(self):
     def getGraphicCoords(self):  
         """Give list of coordinates"""          """Give list of coordinates"""
         subColTypes=['ECHO_collection','ECHO_externalLink','ECHO_resource']          mapColTypes=['ECHO_collection','ECHO_resource']
         ids=[]          areas=[]
         for entry in self.__dict__.keys():          for entry in self.getSubCols(subColTypes=mapColTypes):
             object=getattr(self,entry)              object=entry
             try:          areas.extend(object.getMapAreas())
                 if object.meta_type in subColTypes:          return areas
                     for coordtemp in object.coords:      
                         if len(coordtemp)>3:  
                             coord=coordtemp[0:4]      def deleteMapAreas(self):
                             if hasattr(object,'label') and not object.label=="":      """deletes all map areas from this object"""
                                 ids.append([string.join(coord,", "),object.getId(),object.label,object])      for obs in self.ZopeFind(self, obj_metatypes=['MapArea'], search_sub=1):
                             elif hasattr(object,'title'):          ob = obs[1]
                                 if not object.title=="":          id = ob.id
                                     ids.append([string.join(coord,", "),object.getId(),object.title,object])          parent = ob.aq_parent
                                 else:          print "deleting: ", ob.id
                                     ids.append([string.join(coord,", "),object.getId(),object.getId(),object])          parent._delObject(id)
                             else:      return "Done"
                                 ids.append([string.join(coord,", "),object.getId(),object.getId(),object])  
                       
             except:  
                 """nothing"""  
   
         return ids  
       
   
   
   
     getSubCols = ECHO_helpers.getSubCols      getSubCols = ECHO_helpers.getSubCols
             
                   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 842  def manage_addECHO_collection(self,id,ti Line 2075  def manage_addECHO_collection(self,id,ti
   
 class ECHO_group(ECHO_collection):  class ECHO_group(ECHO_collection):
     """ECHO Gruppe"""      """ECHO Gruppe"""
       security=ClassSecurityInfo()
     meta_type="ECHO_group"      meta_type="ECHO_group"
   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Main Config','action':'ECHO_group_config'},          {'label':'Main Config','action':'ECHO_group_config'},
         {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},          {'label':'Rerender Links','action':'ECHO_rerenderLinksMDWarning'},
         {'label':'Graphics','action':'ECHO_graphicEntry'},          {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
         )          )
       
       security.declareProtected('View','index_html')
   
   
       def getRDF(self,urn=None):
           """rdf of the collection"""
           contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
   
           ret=getRDFDescription(self,self.absolute_url(),urn=urn)
   
           
           if not urn:
               urn=self.absolute_url()
           li="""<RDF:li RDF:resource="%s" />\n"""
           
           
           for content in contents:
               ret+=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):
           """standard page"""
           displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
           #if (len(displayedObjects)==1) and (displayedObjects[0][1].meta_type=="ECHO_collection"): # nur ein Object dann redirect auf dieses Object
           #   return self.REQUEST.RESPONSE.redirect(displayedObjects[0][1].absolute_url())
           
           if 'index.html' in self.__dict__.keys():
               return getattr(self,'index.html')()
           
           elif 'overview' in self.__dict__.keys():
               return self.showOverview()
           elif hasattr(self,'group_index_template'):
               return self.group_index_template()
           elif hasattr(self,'collection_index_template'):
               return self.collection_index_template()    
           elif hasattr(self,'main_index_template'):
               return self.main_index_template()    
   
           pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')
           pt.content_type="text/html"
           return pt()
   
     def ECHO_group_config(self):      def ECHO_group_config(self):
         """Main configuration"""          """Main configuration"""
                   
Line 861  class ECHO_group(ECHO_collection): Line 2142  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=""):      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
         self.imageTag=imageTag          self.imageTag=imageTag
         self.bgcolour=bgcolour          self.bgcolour=bgcolour
                   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 890  class ECHO_group(ECHO_collection): Line 2165  class ECHO_group(ECHO_collection):
   
     def getLogo(self):          def getLogo(self):    
         """logo ausgeben"""          """logo ausgeben"""
                   try:
                       return self.logo
                   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()
   
   
 def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):  def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
     """add a echo group"""      """add a echo group"""
           
   
     newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")      newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
   
       setattr(newObj,'logo',logo)
     self._setObject(id,newObj)      self._setObject(id,newObj)
   
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   Globals.InitializeClass(ECHO_group)
   
   
   class ECHO_userFolder(UserFolder):
       """User folder for Intranet"""
       _domain_auth_mode=1 # Identification via domain
       meta_type="ECHO_userFolder"
       
       def authenticate(self, name, password, request):
           emergency = self._emergency_user
           if name is None:
               return None
           if emergency and name==emergency.getUserName():
               user = emergency
           else:
               user = self.getUser(name)
           if user is not None and user.authenticate(password, request):
               return user
           else:
               return None
   
       def domainSpecMatch(self,spec, request):
           host=''
           addr=''
   
           # Fast exit for the match-all case
           if len(spec) == 1 and spec[0] == '*':
           return 1
   
           if request.has_key('REMOTE_HOST'):
           host=request['REMOTE_HOST']
   
           if request.has_key('REMOTE_ADDR'):
           addr=request['REMOTE_ADDR']
   
           if request.has_key('HTTP_X_FORWARDED_FOR'):
           addr=request['HTTP_X_FORWARDED_FOR']
   
           
           if not host and not addr:
           return 0
   
           if not host:
           try:    host=socket.gethostbyaddr(addr)[0]
           except: pass
           if not addr:
           try:    addr=socket.gethostbyname(host)
           except: pass
   
   
           _host=host.split('.')
           _addr=addr.split('.')
           _hlen=len(_host)
           _alen=len(_addr)
   
           for ob in spec:
           sz=len(ob)
           _ob=ob.split('.')
           _sz=len(_ob)
   
           mo = addr_match(ob)
           if mo is not None:
               if mo.end(0)==sz:
               fail=0
               for i in range(_sz):
                   a=_addr[i]
                   o=_ob[i]
                   if (o != a) and (o != '*'):
                   fail=1
                   break
               if fail:
                   continue
               return 1
   
           mo = host_match(ob)
           if mo is not None:
               if mo.end(0)==sz:
               if _hlen < _sz:
                   continue
               elif _hlen > _sz:
                   _item=_host[-_sz:]
               else:
                   _item=_host
               fail=0
               for i in range(_sz):
                   h=_item[i]
                   o=_ob[i]
                   if (o != h) and (o != '*'):
                   fail=1
                   break
               if fail:
                   continue
               return 1
           return 0
   
   Globals.default__class_init__(ECHO_userFolder)
   
   
   
   def manage_addECHO_userFolder(self,dtself=None,REQUEST=None,**ignored):
       """add a user folder """
       f=ECHO_userFolder()
       self=self.this()
       try:    self._setObject('acl_users', f)
       except: return MessageDialog(
                      title  ='Item Exists',
                      message='This object already contains a User Folder',
                      action ='%s/manage_main' % REQUEST['URL1'])
       self.__allow_groups__=f
       if REQUEST is not None:
           REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
   
   def manage_addECHO_userFolderForm(self):
       """add a user folder form"""
       return manage_addECHO_userFolder(self)
   
   
   
   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"""
   
       security=ClassSecurityInfo()
       
     meta_type="ECHO_root"      meta_type="ECHO_root"
   
       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 getContentOverviewTemplate(self):
       """produces overview template with macro"""
       pt = zptObjectOrFile(self, 'content_overview_template')
       return pt
   
       ###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):
           """needed by main_template"""
           return ""
           
       secondaryLink="" #needed by main_template
       secondaryLinkTitle="" #needed by main_template
       
     def getBgcolour(self):      def getBgcolour(self):
     """hack"""      """hack"""
     return "#dddddd"      return "#dddddd"
Line 932  class ECHO_root(Folder,Persistent,Implic Line 2635  class ECHO_root(Folder,Persistent,Implic
         else:          else:
             retStr="<option>\n"              retStr="<option>\n"
                           
           try: # erste version contentTypes exists
               for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):
                   if selected and (contentType[0]==selected):
                       retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
                   else:                
                       retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
           except:
         try:          try:
             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes="ECHO_contentType"):              for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):
                 if selected and (contentType[0]==selected):                  if selected and (contentType[0]==selected):
                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])                      retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
                 else:                                  else:                
                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])                      retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
         except:          except:
             """nothing"""              """nothing"""
                   
       return retStr
   
       def renderingTypeSelector_HTML(self,selected=None):
            """give type selector"""
        if not selected:
            retStr="<option selected>\n"
        else:
            retStr="<option>\n"
            
        try: # erste version renderingTypes exists
            for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
                if selected and (renderingType[0]==selected):
                    retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
                else:                
                    retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
        except:
            """nothing"""
        return retStr
   
       def renderingTypeSelector_HTML(self,selected=None):
            """give type selector"""
        if not selected:
            retStr="<option selected>\n"
        else:
            retStr="<option>\n"
            
        try: # erste version renderingTypes exists
            for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
                if selected and (renderingType[0]==selected):
                    retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
                else:                
                    retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
        except:
            """nothing"""
         return retStr          return retStr
                           
   
       def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):
            """give type selector"""
   
        if not first:
            if not selected:
                retStr="<option selected>\n"
            else:
                retStr="<option>\n"
        else:
            if not selected:
                retStr="""<option selected value="%s">%s\n"""%first
            else:
                retStr="""<option value="%s">%s\n"""%first
   
        
        try: # erste version copyrightTypes exists
            for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
                if selected and (copyrightType[0]==selected):
                    retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
                else:                
                    retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
            
            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:
            """nothing"""
            
        return retStr
   
       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 copyrightType in self.ZopeFind(self.partners,obj_metatypes=["ECHO_partner"]):
                if selected and (copyrightType[0]==selected):
                    retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
                else:                
                    retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
        except:
            """nothing"""
        return retStr
    
       mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version 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 959  class ECHO_root(Folder,Persistent,Implic Line 2775  class ECHO_root(Folder,Persistent,Implic
                     entry[1].patchContentType(entry[1])                          entry[1].patchContentType(entry[1])    
   
                                   
         return "Rerenderd all links to resources 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):
           """setze viewClassification heuristisch"""
   
       def checkIfArrow(obj):
           if hasattr(obj,'coords'):
               for coordtemp in obj.coords:
   
                   if (len(coordtemp)>4) and not (coordtemp[4]==''):
                       return 4
               return None
           return None
       
           if not obj:
               obj = self
               
           entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])
           
           for entry in entries:
           
           if checkIfArrow(entry[1]):
               setattr(entry[1],'viewClassification','view point')
           else:
               setattr(entry[1],'viewClassification','area')
   
                   #entry[1].contentType == entry[1].content_type
   
                   if entry[1].meta_type in ['ECHO_collection','ECHO_group']:
                       entry[1].patchViewClassification(entry[1])    
   
                   
           return "changed all contenttypes in: "+self.title
   
       def 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 1007  class ECHO_root(Folder,Persistent,Implic Line 2874  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 1018  class ECHO_root(Folder,Persistent,Implic Line 2885  class ECHO_root(Folder,Persistent,Implic
     def link2html(self,str):      def link2html(self,str):
         """link2html fuer VLP muss hier noch raus"""          """link2html fuer VLP muss hier noch raus"""
         if str:          if str:
             print str  
             str=re.sub("\&","&amp;",str)              str=re.sub("\&","&amp;",str)
             dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")              dom=xml.dom.minidom.parseString("<?xml version='1.0' encoding='utf-8'?><txt>"+str+"</txt>")
             links=dom.getElementsByTagName("link")              links=dom.getElementsByTagName("link")
                           
             print "link",links  
             for link in links:              for link in links:
                 link.tagName="a"                  link.tagName="a"
                 ref=link.getAttribute("ref")                  ref=link.getAttribute("ref")
           pn=link.getAttribute("page")
               
                 if self.checkRef(ref):                  if self.checkRef(ref):
                     link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)              if pn:
                   link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref+"&p="+pn)
               else:
                   link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref)
   
   
               newxml=dom.toxml('utf-8')
         
           retStr=regexpTXT.search(newxml)
   
           return retStr.group(1)
   
   
             return dom.toxml('utf-8')  
         return ""          return ""
   
       def xml2html(self,str,quote="yes"):
           """link2html fuer VLP muss hier noch raus"""
   
           if str:
               if quote=="yes2":
                   str=re.sub("\&","&amp;",str)
               #dom=xml.dom.minidom.parseString(str)
           dom = NonvalidatingReader.parseString(str,"http://www.mpiwg-berlin.mpg.de/")
               #links=dom.getElementsByTagName("link")
               links=Ft.Xml.XPath.Evaluate(".//link", contextNode=dom)
               for link in links:
                   #link.tagName="a"
       
                   ref=link.getAttributeNS(EMPTY_NAMESPACE,"ref")
           pn=link.getAttributeNS(EMPTY_NAMESPACE,"page")
   
           cns=link.childNodes[0:]
           
           newLink=dom.createElementNS(EMPTY_NAMESPACE,"a")
           for x in cns:
               newLink.appendChild(x)
           
               
           
           link.parentNode.replaceChild(newLink,link)
                   if self.checkRef(ref):
               if pn:
                   newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn)
               else:
                   newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
   
               #str= dom.toxml('utf-8')
           buf = cStringIO.StringIO()
           PrettyPrint(dom, stream=buf, encoding='UTF-8')
           str = buf.getvalue()
           buf.close()
           #str=PrettyPrint(dom.documentElement,encoding='UTF-8')
           #print link.toxml('utf-8')
           #print type(str)
           retStr=regexpPage.search(str)
           try: # hack warum fehtl manchmal page??
               return retStr.group(1)
           except:
               return str
           return ""
   
     def checkRef(self,ref):      def checkRef(self,ref):
         dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}          if ref[0:3]=='lit':
               if len(self.library_data({ 'id':ref}))>0:
                   return 1
           try:
               if ref[0:7]=="tec_cat":
                   return 1
           except:
               """nothing"""
               
           dbs={'vl_technology':'','vl_people':'','vl_sites':''}
         res=None          res=None
         for db in dbs.keys():          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])))              res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
         return res          return res
                                                                           
Line 1047  class ECHO_root(Folder,Persistent,Implic Line 2978  class ECHO_root(Folder,Persistent,Implic
   
     def PgQuoteString(self,string):      def PgQuoteString(self,string):
         """Quote string"""          """Quote string"""
         #print "PG",string  
         return libpq.PgQuoteString(string)          return libpq.PgQuoteString(string)
                   
     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):
         """partner liste als xml"""           """partner liste als xml""" 
         partners=self.getPartners()          partners=self.getPartners()
         ret="<partners>"          ret="""<?xml version="1.0" encoding="utf-8" ?>
       <partners>"""
           
         for partner in partners:          for partner in partners:
             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)              ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)
   
Line 1094  class ECHO_root(Folder,Persistent,Implic Line 3031  class ECHO_root(Folder,Persistent,Implic
             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))              ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
         return ret          return ret
   
       def getResourcesHTML(self,viewerType=None,filter=None):
           """gebe all ressourcen aus"""
   
           def sortHTML(x,y):
               return cmp(x[1].title,y[1].title)
           
           ret="""<html><body><h2>Resources in ECHO</h3>"""
           
           resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
           ret+="""<h3>Found %i resources</h3>"""%len(resources)
           resources.sort(sortHTML)
           for resource in resources:
               echo_url=resource[1].absolute_url()
               
               if hasattr(resource[1],'title'):
                   title=resource[1].title
               else:
                   title="None"
               if filter:
                   if re.search(filter,title):
                       ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
               else:
                   ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
   
           ret +="""\n</body></html>"""
           
           #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")
           #self.REQUEST.RESPONSE.write(ret)
               return ret
       
       def getResourcesXML(self,viewerType=None,filter=None):
           """gebe all ressourcen aus"""
           ret="""<?xml version="1.0" ?>
                    <index>"""
           for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
   
               echo_url=resource[1].absolute_url()
               if hasattr(resource[1],'link'):
                   viewer_url=resource[1].link
               else:
                   viewer_url="NO URL"
               if filter:
                   if re.search(filter,viewer_url):
                       ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
               else:
                   ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
           ret +="""\n</index>"""
           
           self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
           self.REQUEST.RESPONSE.write(ret)
   
       def getFullTextsXML(self,viewerType=None,filter=None):
           """gebe all ressourcen aus"""
           ret="""<?xml version="1.0" ?>
                    <index>"""
           for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
   
               echo_url=resource[1].absolute_url()
               if resource[1].getFullTextXML(noredirect="yes"):
                   if hasattr(resource[1],'link'):
                       viewer_url=echo_url+"/getFullTextXML"
                   else:
                       viewer_url="NO URL"
                   if filter:
                       if re.search(filter,viewer_url):
                           ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
                   else:
                       ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
           ret +="""\n</index>"""
           
           
           self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
           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):
Line 1105  def manage_addECHO_root(self,id,title,RE Line 3177  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 1127  class ECHO_partner(Image,Persistent): Line 3252  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 1139  class ECHO_partner(Image,Persistent): Line 3270  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 1148  manage_addECHO_partnerForm=DTMLFile('dtm Line 3279  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 1167  def manage_addECHO_partner(self, id, fil Line 3298  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 1182  def manage_addECHO_partner(self, id, fil Line 3313  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.42  
changed lines
  Added in v.1.212

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