File:  [Repository] / ECHO_content / ECHO_collection.py
Revision 1.202: download - view: text, annotated - select for diffs - revision graph
Tue Jan 18 15:40:03 2005 UTC (19 years, 4 months ago) by casties
Branches: MAIN
CVS tags: HEAD
improved sort order for map areas
failed attempt for macros in templates

    1: """New version of the product started February, 8th. Without scientific classification, use content-type for further classification."""
    2: """Echo collection provides the classes for the ECHO content web-site.
    3: 
    4: class ECHO_collection is the basis class for an ECHO collection.
    5: 
    6: class ECHO_resource contains information on ECHO resources (e.g. an Display environment for Metadata
    7: 
    8: class ECHO_externalLink contains information on externalLinks
    9: 
   10: 
   11: """
   12: try:
   13: 	from reportlab.pdfgen import canvas
   14: 	from reportlab.lib.pagesizes import A4
   15: except:
   16: 	print "PDF generation will not work"
   17: 	
   18: 
   19: import string
   20: import tempfile
   21: import re
   22: import os
   23: import OFS.Image
   24: from types import *
   25: from OFS.Cache import Cacheable
   26: from OFS.Image import Image
   27: from Globals import DTMLFile
   28: from OFS.Folder import Folder
   29: from OFS.SimpleItem import SimpleItem
   30: from AccessControl import ClassSecurityInfo
   31: from AccessControl.User import UserFolder
   32: from Globals import InitializeClass
   33: from Globals import DTMLFile
   34: import Globals
   35: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   36: from Products.PageTemplates.PageTemplate import PageTemplate
   37: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   38: from Globals import Persistent, package_home
   39: from Acquisition import Implicit
   40: 
   41: import urllib
   42: import smtplib
   43: import time
   44: from Ft.Xml.Domlette import NonvalidatingReader
   45: from Ft.Xml.Domlette import PrettyPrint
   46: from Ft.Xml import EMPTY_NAMESPACE
   47: 
   48: import Ft.Xml.XPath
   49: import cStringIO
   50: import zLOG
   51: 
   52: try:
   53: 	from psycopg import libpq
   54: except:
   55: 	try:
   56: 		from pyPgSQL import libpq
   57: 	except:
   58: 		print "ECHO_collection: Warning - No libpq imported!"
   59: 		
   60: import xml.dom.minidom
   61: 
   62: import urllib
   63: import xml.dom.minidom
   64: import ECHO_helpers
   65: from ECHO_helpers import *
   66: from ECHO_language import *
   67: 
   68: 
   69: #regexp for extracting elements from xml
   70: patternTXT=r"<\s*txt.*?>(.*?)</txt>"
   71: regexpTXT = re.compile(patternTXT, re.IGNORECASE + re.DOTALL)
   72: patternPage=r"<\s*page.*?>(.*?)</page>"
   73: regexpPage = re.compile(patternPage, re.IGNORECASE + re.DOTALL)
   74: 
   75: 	    
   76: 
   77: def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs=""):
   78: 
   79:         """Allegemeine Informationen zu einer ECHO Collection"""
   80: 
   81:         self.label = label
   82:         self.title=title
   83:         self.description=description
   84:         self.contentType=contentType
   85:         self.responsible=responsible
   86:         self.credits=toList(credits)
   87:         self.weight=weight
   88: 
   89:             
   90: class ECHO_copyright(Folder,ECHO_basis):
   91: 	"""Copyright informationen"""
   92: 	meta_type="ECHO_copyright"
   93: 	
   94: 	
   95: 	
   96: 	def __init__(self,id,title,copyrights):
   97: 		"""init"""
   98: 		self.title=title
   99: 		self.id=id
  100: 		self.copyrights=copyrights[0:]
  101: 
  102: 	def getCopyrights(self):
  103: 		"""return coyprights"""
  104: 		return self.copyrights
  105: 	        
  106: 	manage_options = Folder.manage_options+(
  107: 		{'label':'Main Config','action':'ECHO_copyright_configForm'},
  108: 		)
  109: 
  110: 
  111: 	def ECHO_copyright_configForm(self):
  112: 		"""change form"""
  113: 		pt=zptFile(self, 'zpt/ChangeECHO_copyright')
  114: 		pt.content_type="text/html"
  115: 		return pt()
  116: 
  117: 	def ECHO_copyright_config(self,title,RESPONSE=None):
  118: 		"""change"""
  119: 		self.title=title
  120: 		self.copyrights=[]
  121: 		self.copyrights=getCopyrightsFromForm(self,self.REQUEST.form)[0:]
  122: 
  123: 		if RESPONSE is not None:
  124: 			RESPONSE.redirect('manage_main')
  125: 
  126: 		
  127: def manage_addECHO_copyrightForm(self):
  128:     """Form for adding"""
  129:     pt=zptFile(self, 'zpt/AddECHO_copyright.zpt')
  130:     return pt()
  131: 
  132: def manage_addECHO_copyright(self, id,title,RESPONSE=None):
  133: 	"""add the copyright"""
  134: 
  135: 	meta_type="ECHO_copyright"
  136: 	
  137: 	#first generate copyrights as list of tripels (mediaType,partner,copyrightType)
  138: 	
  139: 		
  140: 
  141: 	self._setObject(id, ECHO_copyright(id, title,getCopyrightsFromForm(self,self.REQUEST.form)))
  142: 
  143: 	if RESPONSE is not None:
  144: 		RESPONSE.redirect('manage_main')
  145: 	
  146: class ECHO_layoutTemplate(ZopePageTemplate,ECHO_basis):
  147:     """Create a layout Template for different purposes"""
  148: 
  149:     meta_type="ECHO_layoutTemplate"
  150: 
  151:     def __init__(self, id, text=None, content_type=None,EchoType=None):
  152:         self.id = str(id)
  153: 
  154:         self.ZBindings_edit(self._default_bindings)
  155:         if text is None:
  156:             self._default_content_fn = os.path.join(package_home(globals()),
  157:                                                'zpt/ECHO_%s_template_standard.zpt'%EchoType)
  158:             text = open(self._default_content_fn).read()
  159:         self.pt_edit(text, content_type)
  160: 
  161: 
  162: def manage_addECHO_layoutTemplateForm(self):
  163:     """Form for adding"""
  164:     pt=zptFile(self, 'zpt/AddECHO_layoutTemplate.zpt')
  165:     return pt()
  166: 
  167: 
  168: def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
  169:     "Add a Page Template with optional file content."
  170:     if type(EchoType)==StringType:
  171:         EchoTypes=[EchoType]
  172:     else:
  173:         EchoTypes=EchoType
  174:         
  175:     for singleType in EchoTypes:
  176: 
  177:         id = str(singleType)+"_template"
  178:         if REQUEST is None:
  179:             self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))
  180:             ob = getattr(self, id)
  181:             
  182:             if title:
  183:                 ob.pt_setTitle(title)
  184:             return ob
  185:         else:
  186:             file = REQUEST.form.get('file')
  187:             headers = getattr(file, 'headers', None)
  188:             if headers is None or not file.filename:
  189:                 zpt = ECHO_layoutTemplate(id,EchoType=singleType)
  190:             else:
  191:                 zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))
  192: 
  193:             self._setObject(id, zpt)
  194:             ob = getattr(self, id)
  195:             if title:
  196:                 ob.pt_setTitle(title)
  197: 
  198:             try:
  199:                 u = self.DestinationURL()
  200:             except AttributeError:
  201:                 u = REQUEST['URL1']
  202: 
  203:             
  204:     REQUEST.RESPONSE.redirect(u+'/manage_main')
  205:     return ''
  206: 
  207: class ECHO_fullText(ZopePageTemplate,ECHO_basis,ECHO_language):
  208: 	"""echo fulltext in xml"""
  209: 
  210: 	meta_type="ECHO_fullText"
  211: 
  212: 	
  213: 	def getPage(self,nr='1'):
  214: 		"""get page n"""
  215: 		dom=xml.dom.minidom.parseString(self())
  216: 		pages=dom.getElementsByTagName('page')
  217: 		
  218: 		return pages[int(nr)-1].toxml('utf-8')
  219: 	
  220: # Product registration and Add support
  221: manage_addECHO_fullTextForm = PageTemplateFile(
  222:     'zpt/AddECHO_fullText.zpt', globals())
  223: 
  224: def manage_addECHO_fullText(self, id, title=None, text=None,
  225:                            REQUEST=None, submit=None):
  226:     "Add a Page Template with optional file content."
  227: 
  228:     id = str(id)
  229:     if REQUEST is None:
  230:         self._setObject(id, ECHO_fullText(id, text))
  231:         ob = getattr(self, id)
  232:         if title:
  233:             ob.pt_setTitle(title)
  234:         return ob
  235:     else:
  236:         file = REQUEST.form.get('file')
  237:         headers = getattr(file, 'headers', None)
  238:         if headers is None or not file.filename:
  239:             zpt = ECHO_fullText(id)
  240:         else:
  241:             zpt = ECHO_fullText(id, file, headers.get('content_type'))
  242: 
  243:         self._setObject(id, zpt)
  244: 
  245:         try:
  246:             u = self.DestinationURL()
  247:         except AttributeError:
  248:             u = REQUEST['URL1']
  249: 
  250:         if submit == " Add and Edit ":
  251:             u = "%s/%s" % (u, urllib.quote(id))
  252:         REQUEST.RESPONSE.redirect(u+'/manage_main')
  253:     return ''
  254: 
  255: 
  256: class ECHO_resource(Folder,Persistent,ECHO_basis):
  257:     """ECHO Ressource"""
  258:     security=ClassSecurityInfo()
  259:     meta_type='ECHO_resource'
  260: 
  261: #    viewClassificationList=viewClassificationListMaster
  262: 
  263:     getSubCols = ECHO_helpers.getSubCols
  264: 
  265:     security.declareProtected('View','index_html')
  266: 
  267:     
  268:   
  269:     security.declareProtected('View','createPDF')
  270:     def createPDF(self,RESPONSE=None,local=None,dpi=150):
  271: 	    """erzeuge pdf file"""
  272: 	    pages=1
  273: 	    dpi=float(dpi)
  274: 	    imagePath=self.getImagePath().replace("/mpiwg/online","")
  275: 	    
  276: 	    
  277: 	    image="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn="+imagePath+"&dw=%i&dh=%i&pn=%i"
  278: 	    xmlInfo="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/dlInfo-xml.jsp?fn="+imagePath
  279: 
  280: 	    dom=xml.dom.minidom.parse(urllib.urlopen(xmlInfo))
  281: 	    for parameter in dom.getElementsByTagName('parameter'):
  282: 		    if parameter.getAttribute('name')=="pt":
  283: 			    pages=int(parameter.getAttribute('value'))
  284: 			    break
  285: 	    
  286: 
  287: 	    tempdir="/tmp/archivesImageServer"
  288: 	    if not os.path.exists(tempdir):
  289: 		    os.mkdir(tempdir) 
  290:   
  291: 	    tmpPath=tempfile.mkdtemp(dir=tempdir)
  292: 	    
  293: 
  294: 	    tmpZip=tempfile.mktemp(dir=tempdir)
  295: 
  296: 	    tmpFn=os.path.split(tmpZip)[1]
  297: 
  298: 
  299:     
  300: 
  301: 	    if RESPONSE:
  302: 		    RESPONSE.setHeader("Content-Type","text/html")
  303: 		    RESPONSE.write("<h1>I am creating  the pdf</h1>")
  304: 		    txt="<h3>1. step: getting the images( %i pages)</h3>"%pages
  305: 		    RESPONSE.write(txt)
  306: 
  307: 	    c=canvas.Canvas(tmpZip)
  308: 	    for i in range(1,pages+1):
  309: 		    if RESPONSE:
  310: 			    RESPONSE.write(str("<p>Get Page: %i<br>\n"%i))
  311: 		    faktor=dpi/72.0
  312: 		    
  313: 		    fn=tmpPath+"/%i"%i
  314: 
  315: 		    width,height=A4
  316: 		    #print image%(width*faktor,height*faktor,i)
  317: 		    url=urllib.urlopen(image%(width*faktor,height*faktor,i)).read()
  318: 		    fh=file(fn,"w")
  319: 		    fh.write(url)
  320: 		    fh.close()
  321: 
  322:     
  323: 
  324: 		    c.drawImage(fn,0,0,width=width,height=height)
  325: 		    c.showPage()
  326: 	    c.save()
  327: 	    if RESPONSE:
  328: 		    RESPONSE.write("<p>finished<br>\n")
  329: 
  330: 	    if RESPONSE:
  331: 		    len=os.stat(tmpZip)[6]
  332: 		    downloadUrl=self.absolute_url()+"/downloadPDF"
  333: 		    RESPONSE.write("""<h1><a href="downloadPDF?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))
  334: 		    RESPONSE.write("""<p>The file will be stored for a while, you can download it later, the URL is:</p>
  335: 		    <p><a href="downloadPDF?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn))
  336: 		    RESPONSE.close()
  337: 
  338: 
  339:     def downloadPDF(self,fn):
  340: 	    """download prepared set"""
  341: 	    filename="/tmp/archivesImageServer/"+fn
  342: 	    namePDF=self.getId()+".pdf"
  343: 	    self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%namePDF)
  344: 	    self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
  345: 	    len=os.stat(filename)[6]
  346: 	    self.REQUEST.RESPONSE.setHeader("Content-Length",len)
  347: 	    images=file(filename).read()
  348: 	    self.REQUEST.RESPONSE.write(images)
  349: 	    self.REQUEST.RESPONSE.close()
  350: 
  351: 
  352:     def getRDF(self,urn=None):
  353: 	    """rdf"""
  354: 	    ret=getRDFDescription(self,self.link,urn=urn)
  355: 	    return ret+self.createSubElementRDF(urn=urn) 
  356: 
  357:   
  358:     def getAccessRightSelectorHTML(self,outlook="select"):
  359: 	    """htmlselector"""
  360: 	    values=['free','mpiwg']
  361: 	    
  362: 	    if outlook=="select":
  363: 		    ret="""<select name="%s">"""%self.getId()
  364: 
  365: 		    for value in values:
  366: 			    if value==self.getAccessRightMD():
  367: 				    ret+="<option selected>%s</option>"%value
  368: 			    else:
  369: 				    ret+="<option>%s</option>"%value
  370: 		    return ret+"</select>"
  371: 
  372: 	    else:
  373: 		    ret=""
  374: 		    for value in values:
  375: 			    
  376: 			    if value==self.getAccessRightMD():
  377: 				    ret+="""<input type="radio" name="%s" value="%s" checked>%s"""%(self.getId(),value,value)
  378: 			    else:
  379: 				    ret+="""<input type="radio" name="%s" value="%s">%s"""%(self.getId(),value,value)
  380: 		    return ret
  381: 
  382: 
  383:     
  384:     def getAccessRightMD(self):
  385: 		"""set accessright"""
  386: 		url=self.metalink
  387: 
  388: 		try:
  389: 			geturl=""
  390: 			for line in ECHO_helpers.urlopen(url).readlines():
  391: 				geturl=geturl+line
  392: 
  393: 
  394: 		except:
  395: 			return (None,"Cannot open: "+url)
  396: 
  397: 		try:
  398: 			dom=xml.dom.minidom.parseString(geturl)
  399: 			root=dom.getElementsByTagName('resource')[0]
  400: 		except:
  401: 			return (None,"Cannot parse: "+url+"<br>"+geturl)
  402: 
  403: 		internal=dom.getElementsByTagName('internal')
  404: 		if internal:
  405: 			institution=dom.getElementsByTagName('institution')
  406: 			return getText(institution[0].childNodes)
  407: 		
  408: 		free=dom.getElementsByTagName('free')
  409: 		if free:
  410: 			return "free"
  411: 
  412: 		return "free" #default free
  413: 
  414:     def changeAccessRightMD(self,accessright,RESPONSE=None):
  415: 	    """change the rights"""
  416: 	    
  417: 	    params="accessright=%s"%accessright
  418: 
  419: 
  420: 	    #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()
  421: 
  422: 	    
  423: 	    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()
  424: 
  425: 	  
  426: 	    if RESPONSE is not None:
  427: 			RESPONSE.redirect('manage_main')
  428: 
  429: 		
  430:     def setAccessRightXML(self,accessright):
  431: 		"""set accessright"""
  432: 		url=self.metalink
  433: 
  434: 		try:
  435: 			geturl=""
  436: 			for line in ECHO_helpers.urlopen(url).readlines():
  437: 				geturl=geturl+line 
  438: 
  439: 
  440: 		except:
  441: 			return (None,"Cannot open: "+url)
  442: 
  443: 		try:
  444: 			dom=xml.dom.minidom.parseString(geturl)
  445: 			root=dom.getElementsByTagName('resource')[0]
  446: 		except:
  447: 			return (None,"Cannot parse: "+url+"<br>"+geturl)
  448: 
  449: 		metanodes=dom.getElementsByTagName('access-conditions')
  450: 
  451: 		if not metanodes:
  452: 			nodenew=dom.createElement('access-conditions')
  453: 			root.appendChild(nodenew)
  454: 			metanode=nodenew
  455: 		else:
  456: 			metanode=metanodes[0]
  457: 
  458: 		accesses=metanode.getElementsByTagName('access')
  459: 
  460: 		if not accesses:
  461: 			nodenew2=dom.createElement('access')
  462: 			metanode.appendChild(nodenew2)
  463: 			metanode2=nodenew2
  464: 		else:
  465: 			metanode2=accesses[0]
  466: 
  467: 		internal=metanode.getElementsByTagName('internal')
  468: 
  469: 		if internal:
  470: 			metanode2.removeChild(internal[0]).unlink()
  471: 
  472: 		free=metanode.getElementsByTagName('free')
  473: 		
  474: 		if free:
  475: 			metanode2.removeChild(internal[0]).unlink()
  476: 
  477: 
  478: 		if accessright=='free':
  479: 			nodenew3=dom.createElement('free')
  480: 			metanode2.appendChild(nodenew3)
  481: 		elif accessright=='mpiwg':
  482: 			nodenew3=dom.createElement('internal')
  483: 			nodenew4=dom.createElement('institution')
  484: 			metanodetext=dom.createTextNode('mpiwg')
  485: 			nodenew4.appendChild(metanodetext)
  486: 			nodenew3.appendChild(nodenew4)
  487: 			metanode2.appendChild(nodenew3)
  488: 
  489: 		return dom.toxml().encode('utf-8')
  490: 
  491:     def setStartPageForm(self):
  492: 	    """Form for changing the startpage"""
  493: 
  494: 	    
  495: 	    pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPage.zpt')
  496:             pt.content_type="text/html"
  497:             return pt()
  498:     
  499: 
  500:     def createImageUrl(self,pn=1):
  501: 	    """create ImageUrl"""
  502: 
  503: 	    
  504: 	    resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
  505: 	    
  506: 	    digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')
  507: 	    images=readFieldFromXML(self.metalink,'texttool','image')
  508: 
  509: 
  510: 	    if (not resourcepath) or (not digiliburlprefix) or (not images):
  511: 		    zLOG.LOG("ECHO (createImageUrl)",zLOG.ERROR,"Cannot create ImageUrl for %s"%self.absolute_url())
  512: 		    return None
  513: 	    resourcepath=resourcepath.replace('/mpiwg/online','')
  514: 	    if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"
  515: 
  516: 	    if (not images) or (not resourcepath): return None
  517: 
  518: 	    return "%sfn=%s&pn=%i"%(digiliburlprefix,resourcepath+"/"+images,pn)
  519:     
  520:     def copyTitleToInfoXML(self,RESPONSE=None):
  521: 	    """copy title from the resource"""
  522: 	    presentationXML=readFieldFromXML(self.metalink,'texttool','presentation')
  523: 	    resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
  524: 	    if (not presentationXML) or (not resourcepath): 
  525: 		if RESPONSE:
  526: 			RESPONSE.write("Error: %s\n"%self.getId())
  527: 		else:
  528: 			return None,self.absolute_url()
  529: 
  530: 	    try:
  531: 		    fh=file(os.path.join(resourcepath,presentationXML),'w')
  532: 		    fh.write("""<info>
  533: 		    <author></author>
  534: 		    <title>%s</title>
  535: 		    <date></date>
  536: 		    <display>yes</display>
  537: 		    </info>"""%self.title)
  538: 		    fh.close()
  539: 		    return 1,self.getId()
  540: 	    except:
  541: 		    if RESPONSE:
  542: 			    RESPONSE.write("Error: %s\n"%self.getId())
  543: 		    else:
  544: 			    return None,self.absolute_url()
  545: 
  546: 	    
  547:     def setStartPage(self,startpage=None,RESPONSE=None):
  548: 	    """set start page, if no startpage defined use the generic one of the resource"""
  549: 
  550: 	    if (not (type(startpage)==StringType)):
  551: 		    if ("__generic" in startpage): # checke ob generic in der liste
  552: 			    startpage=self.absolute_url()+"/startpage_html"
  553: 		    elif ("__firstPage" in startpage): # checke ob generic in der liste
  554: 			    startpage=self.createImageUrl()
  555: 			    
  556: 	    if (not startpage):
  557: 		    startpage=self.absolute_url()+"/startpage_html"
  558: 	    elif (startpage=="__generic"):
  559: 		    startpage=self.absolute_url()+"/startpage_html"
  560: 	    elif (startpage=="__firstPage"):
  561: 		        startpage=self.createImageUrl()
  562:     
  563: 	    params="startpage=%s"%startpage
  564: 	    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))
  565: 																 
  566: 	    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()
  567: 	
  568: 	    
  569: 	    path=self.metalink
  570: 	    
  571: 	    path=re.sub(self.REQUEST['SERVER_URL'],'',path)
  572: 	    path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
  573: 	    
  574: 	    path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
  575: 	    path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
  576: 	    path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
  577:             path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
  578: 	    path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
  579: 	    path=re.sub('http://vision.mpiwg-berlin.mpg.de','',path) # falls vision als server
  580: 	    path=re.sub('http://xserve02.mpiwg-berlin.mpg.de:18880','',path) # falls vision als server
  581: 	    path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
  582: 	    path=re.sub('/index.meta','',path) 
  583: 
  584: 
  585: 	    ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
  586: 
  587: 	    if RESPONSE is not None:
  588: 			RESPONSE.redirect('manage_main')
  589: 
  590:     def changeViewerTemplateSetForm(self):
  591: 	    """change the viewer template set"""
  592: 	    pt=zptFile(self, 'zpt/changeResourceViewerTemplateSet')
  593:             return pt()
  594: 
  595: 
  596:    
  597:     def getTextToolsField(self,name,default=''):
  598:         """Lese Textoolsfelder aus index.meta im path aus"""
  599:         
  600:         try:
  601:             dom=xml.dom.minidom.parse(self.metalink)
  602:             node=dom.getElementsByTagName('texttool')[0] #getNode
  603:             subnode=node.getElementsByTagName(name)[0]
  604: 
  605:             # bei text wird nur der Folder gebraucht
  606:             if name=="text":
  607:                 splitted=getText(subnode.childNodes).split("/")
  608:                 return splitted[len(splitted)-2]
  609:             else:
  610:                 return getText(subnode.childNodes)
  611:         except:
  612:             return default
  613:    
  614: 
  615:     def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
  616: 	    """changeit"""
  617: 
  618: 	    paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate','digiliburlprefix']
  619: 
  620: 	    
  621: 	    #writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)
  622: 
  623: 	    params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
  624: 
  625: 	    
  626: 	    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()
  627: 
  628: 	    #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)
  629: 	    # hack Pfad auf die Dokumente
  630: 	    path=self.metalink
  631: 	    
  632: 	    
  633: 
  634: 	    path=re.sub('/index.meta','',path) 
  635: 
  636: 	    path=re.sub(self.REQUEST['SERVER_URL'],'',path)
  637: 	    path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
  638: 
  639:   	    path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
  640:   	    path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
  641: 	    path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
  642: 
  643: 	    path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
  644: 	    path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
  645: 	    path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
  646: 	    path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
  647: 
  648: 	    path=re.sub('http://vision.rz-berlin.mpg.de','',path) # falls vision als server
  649: 
  650: 	    return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
  651: 
  652: 
  653: 	    if RESPONSE is not None:
  654: 			RESPONSE.redirect('manage_main')
  655: 
  656:     
  657: 
  658: 	
  659:     def content_html(self):
  660:         """template fuer content"""
  661:         return ECHO_basis.content_html(self,'resource')
  662:     
  663: #    def getViewClassification(self):
  664: #        if hasattr(self,'viewClassification'):
  665: #            return self.viewClassification
  666: #        else:
  667: #            return ""
  668: 
  669:     def getFullTextXML(self,noredirect=None):
  670: 	    """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
  671: 
  672: 	    try:
  673: 		    #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"open %s"%self.metalink)
  674: 		    fh=ECHO_helpers.urlopen(self.metalink)
  675: 		    #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"opened %s"%self.metalink)
  676: 		    dom=xml.dom.minidom.parse(fh)
  677: 		    texttools=dom.getElementsByTagName('texttool')
  678: 		    text=texttools[0].getElementsByTagName('text')
  679: 		    texturl=getText(text[0].childNodes)
  680: 
  681: 		    #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"found %s"%texturl)
  682:                     fh.close()
  683: 		    #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"closed fh")
  684: 		    #keine url
  685: 		    if not (texturl.split(":")[0] in ['http','ftp','file']): 
  686: 			if not noredirect:
  687: 			    return file(texturl).read()
  688:                         else:
  689: 			    return texturl
  690: 
  691: 		    if not noredirect:
  692:                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')	
  693: 		            zLOG.LOG("ECHO Fulltext",zLOG.INFO,"redirect to:%s"%texturl)
  694: 			    self.REQUEST.RESPONSE.redirect(texturl)
  695: 		    else:
  696: 			    return texturl
  697: 	    except:
  698: 
  699: 		    if not noredirect:
  700: 			    self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
  701: 			    self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
  702: 		    else:
  703: 			    return "<error>no fulltext available</error>"
  704: 
  705:     def getImagePath(self):
  706: 	    """gibt pfad zum image aus"""
  707: 	    return self.getImageView(noredirect="yes",onlyPath="yes")
  708:     
  709:     def getImageView(self,noredirect=None,onlyPath=None):
  710: 	    """getImages; give Imageviewr  and <error></error> if somthing goes wrong."""
  711: 	    try:
  712: 		    fh=ECHO_helpers.urlopen(self.metalink)
  713: 		    dom=xml.dom.minidom.parse(fh)
  714: 		    texttools=dom.getElementsByTagName('texttool')
  715: 		    text=texttools[0].getElementsByTagName('image')
  716: 		    imagetemp=getText(text[0].childNodes)
  717: 		    
  718: 		    text=dom.getElementsByTagName('archive-path')
  719: 		    archivepath=getText(text[0].childNodes)
  720: 		    archivepath=re.sub('/mpiwg/online/','',archivepath)	
  721: 		    imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp
  722: 		    fh.close()
  723: 
  724: 		    if not noredirect:
  725:                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')	
  726: 			    self.REQUEST.RESPONSE.redirect(imageurl)
  727: 		    else:
  728: 			    if not onlyPath:
  729: 				    return imageurl
  730: 			    else:
  731: 				    return archivepath+"/"+imagetemp
  732: 	    except:
  733: 
  734: 		    if not noredirect:
  735: 			    self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
  736: 			    self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
  737: 		    else:
  738: 			    return "<error>no images available</error>"
  739: 
  740:     
  741:     def getCopyrightsHTML(self):
  742: 	    """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
  743: 	    
  744: 	    if hasattr(self,'copyrightModel'):
  745: 		    obj=self.copyrightModel
  746: 		    
  747: 	    else:
  748: 		    return "ERROR"
  749: 	    ret=[]
  750: 	    
  751: 	    for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
  752: 		    
  753: 		    
  754: 		    try:
  755: 		        if hasattr(self.copyrightTypes,copyright[2]):
  756: 		             copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
  757: 		             link="copyrightTypes/"+copyright[2]+'/copyright.html'
  758: 		        else:
  759: 		             copyrightTypeObj=getattr(obj,copyright[2])
  760: 		             link="copyrightModel/"+copyright[2]+'/copyright.html'
  761: 		             
  762: 		        label=copyrightTypeObj.label
  763: 		        url=getattr(copyrightTypeObj, 'url', '')
  764: 			    
  765: 		        if url!='':
  766: 			         ret.append((url,copyright[0],copyright[1],copyright[2],label))
  767: 		        else:
  768: 			        if hasattr(copyrightTypeObj, 'copyright.html'):
  769: 			             ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
  770: 			        else:
  771: 			             ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
  772: 		    except:
  773: 			    """nothing"""
  774: 		    
  775: 	    return ret
  776: 	    
  777:     def getInstitutionsHTML(self):
  778: 		"""gibt Liste der foerdernden Institutionen aus"""
  779: 		
  780: 		if hasattr(self,'support'):
  781: 			obj=self.support
  782: 			ret=obj.getSupporter()
  783: 			return ret
  784: 		else:
  785: 			return ''
  786: 			
  787:     
  788:     def getCredits(self):
  789:         """Ausgabe der credits"""
  790:         if self.credits:
  791:             return self.credits
  792:         else:
  793:             return []
  794: 
  795: 
  796:     
  797:     def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
  798: 
  799:         self.id = id
  800:         """Festlegen der ID"""
  801:         
  802:         self.label = label
  803:         self.link= link
  804:         self.metalink=metalink
  805:         self.title=title
  806:         self.weight=weight
  807:         self.credits=toList(credits)
  808:         self.description=description
  809:         self.contentType=contentType
  810: 	self.copyrightType=copyrightType
  811: 	self.renderingType=renderingType
  812:         self.responsible=responsible
  813:         self.resourceID=resourceID
  814: 	
  815:         if coords:
  816:             coordsnew=[ string.split(x,",") for x in coords]
  817:         else:
  818:             coordsnew=[]
  819:         
  820:         self.coords=coordsnew
  821: #	self.viewClassification=""
  822: 
  823: 
  824: 
  825:     def getContentType(self):
  826: 	    try:
  827: 		    return self.contentType
  828: 	    except:
  829: 		    return ""
  830: 
  831:     def getCopyrightType(self):
  832: 	    try:
  833: 		    return self.copyrightType
  834: 	    except:
  835: 		    return ""
  836: 
  837:     def getRenderingType(self):
  838: 	    try:
  839: 		    return self.renderingType
  840: 	    except:
  841: 		    return ""
  842: 
  843:     def ECHO_resource_config(self):
  844:         """Main configuration"""
  845: 
  846:         if not hasattr(self,'weight'):
  847:             self.weight=""
  848: 
  849:         pt=zptFile(self, 'zpt/ChangeECHO_resource.zpt')
  850:         return pt()
  851:     
  852: 
  853:     def ECHO_resource_config_main(self):
  854:         """Main configuration"""
  855:         if not hasattr(self,'weight'):
  856:             self.weight=""
  857:         pt=zptFile(self, 'zpt/ChangeECHO_resource_main.zpt')
  858:         return pt()
  859: 
  860:     def ECHO_resource_config_coords(self):
  861:         """Coords configuration """
  862:         pt=zptFile(self, 'zpt/ChangeECHO_resource_coords.zpt')
  863:         return pt()
  864: 
  865:     def ECHO_resource_config_credits(self):
  866:         """Main configuration"""
  867:         pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')
  868:         return pt()
  869: 
  870:     def ECHO_resource_config_metadata(self):
  871:         """Main configuration"""
  872: 	if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
  873: 		self.metaDataHash={}
  874: 		self.contentType=self.bib_type
  875: 		for data in self.metadata:
  876: 			data_neu=re.sub('-','_',data)
  877: 			self.meta
  878:                         DataHash[data_neu]=getattr(self,data)[0:]
  879: 
  880: 	
  881:         pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')
  882:         return pt()
  883: 
  884: 
  885:     
  886: 
  887:     def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):
  888:         """Aenderung der Properties"""
  889: 	self.resourceID=resourceID
  890: 	self.title=title
  891: 	self.label=label
  892: 	self.description=description
  893: 
  894: 	self.contentType=contentType
  895: 	self.renderingType=renderingType
  896: 	self.weight=weight
  897: 	
  898:         self.link=link
  899:         self.metalink=metalink
  900:         
  901:         if RESPONSE is not None:
  902:             RESPONSE.redirect('manage_main')
  903: 
  904: 
  905:     def changeECHO_resource_coords(self,RESPONSE=None):
  906:         """Aenderung der Properties - coords"""
  907: 	#return self.REQUEST
  908: 	for area in self.getMapAreas():
  909: 	    id = area.getId()
  910: 	    if self.REQUEST.has_key('del.'+id):
  911: 		# delete this area
  912: 		self._delObject(id)
  913: 		# return to same menu
  914: 		if RESPONSE is not None:
  915: 		    RESPONSE.redirect('ECHO_resource_config_coords')
  916: 		return
  917: 	    # modify this area
  918: 	    coordstring = self.REQUEST.get('coords.'+id, '')
  919: 	    coords = string.split(coordstring, ',')
  920: 	    angle = self.REQUEST.get('angle.'+id, '0')
  921: 	    type = self.REQUEST.get('type.'+id, 'area')
  922: 	    if len(coords) == 4:
  923: 		area.setCoordString(coordstring)
  924: 		area.setAngle(angle)
  925: 		area.setType(type)
  926: 	# return to main menu    
  927: 	if RESPONSE is not None:
  928: 	    RESPONSE.redirect('manage_main')
  929: 
  930: 
  931:     def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
  932:         """Aenderung der Properties"""
  933: 	self.credits=credits
  934: 	self.responsible=responsible
  935: 	self.copyrightType=copyrightType
  936:         
  937:         if RESPONSE is not None:
  938:             RESPONSE.redirect('manage_main')
  939: 
  940: 
  941:     def changeECHO_resource_metadata_local(self,RESPONSE=None):
  942: 	    """change metadata"""
  943: 	    tags=self.findTagsFromMapping(self.contentType)
  944: 	    for field in tags[1]:
  945: 		    self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]
  946: 			
  947: 
  948: 	    	    
  949: 	    if RESPONSE is not None:
  950: 		    RESPONSE.redirect('manage_main')
  951: 
  952:     def changeECHO_resource_metadata(self,RESPONSE=None):
  953: 	    """change metadata"""
  954: 	    tags=self.findTagsFromMapping(self.contentType)
  955: 	    self.OSAS_meta={}
  956: 	    for field in tags[1]:
  957: 		    try:
  958: 			    self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
  959: 			    self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
  960: 		    except:
  961: 			    """nothing"""
  962: 
  963: 	    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()
  964: 
  965: 
  966: 	    if RESPONSE is not None:
  967: 		    RESPONSE.redirect('manage_main')
  968: 
  969: 
  970:     def getMDValue(self,fieldName,empty=None):
  971: 	    if empty:
  972: 		    return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)
  973: 	    
  974: 	    else:
  975: 		    return self.metaDataHash.get(fieldName,empty)
  976: 	    
  977:     def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
  978: 	    """new index.meta"""
  979: 	    self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
  980: 
  981: 	    if not hasattr(self,'metaDataHash'):
  982: 		
  983: 		    self.copyIndex_meta2echo_resource()
  984: 	    try:
  985: 		    return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
  986: 	    except:
  987: 		    return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
  988: 
  989:     def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
  990: 	    """schreibe md"""
  991: 	    
  992: 	    try:
  993: 		    
  994: 		    return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
  995: 	    except:
  996: 		    return "<error> no metadata stored</error>"
  997:     
  998:     def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
  999: 	    """prints out metadata as stored in the echo environment, format is the index.meta format"""
 1000: 	    self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
 1001: 	    return writeMetadata(self.metalink,self.metaDataHash)
 1002: 
 1003:     def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
 1004:         """Aenderung der Properties"""
 1005:         
 1006:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
 1007:         self.link=link
 1008:         self.metalink=metalink
 1009:         
 1010:         if RESPONSE is not None:
 1011:             RESPONSE.redirect('manage_main')
 1012:             
 1013:             
 1014:     manage_options = Folder.manage_options+(
 1015:         {'label':'Main Config','action':'ECHO_resource_config_main'},
 1016: 	{'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
 1017: 	{'label':'Graphic Coords','action':'ECHO_graphicEntry'},
 1018:         {'label':'Sync Metadata','action':'ECHO_getResourceMD'},
 1019: 	{'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
 1020: 	{'label':'set/change startpage','action':'setStartPageForm'},
 1021: 	{'label':'Copy MD for indexing and search','action':'copySearchFields'},
 1022: 	)
 1023: 
 1024: 
 1025:     def isDefinedInThisSet(self,fields,field):
 1026: 	    """checks if field is defined in fields"""
 1027: 	    if (fields[0].has_key(field)) and not (fields[0][field]==""):
 1028: 		    return 1
 1029: 	    else:
 1030: 		  
 1031: 		    return 0
 1032: 	    
 1033:     def getFieldLabel(self,fields,field):
 1034:         """get labels"""
 1035:         try:
 1036:             ret =fields[0][field]
 1037:             if ret == "":
 1038:                 return field
 1039:             else:
 1040:                 return ret
 1041:         except:
 1042:             return field
 1043: 
 1044: 
 1045: 
 1046:     def getFieldTag(self,fields,field):
 1047:         """get labels"""
 1048:         try:
 1049:             ret =fields[0][field]
 1050:             if ret == "":
 1051:                 return field
 1052:             else:
 1053:                 return ret
 1054:         except:
 1055:             return field
 1056: 
 1057:     
 1058:         
 1059:     def getFieldValue(self,field):
 1060:         """get value"""
 1061: 	
 1062:         try:
 1063: 	
 1064:             ret=self.metaDataHash[field]
 1065:             if ret == "":
 1066:                 return None
 1067:             else:
 1068:                 return ret
 1069:         except:
 1070:             return None
 1071: 
 1072:     def getMetaDataHash(self):
 1073: 	    """md hash"""
 1074: 	    return self.metaDataHash
 1075:     
 1076:     def setFieldValue(self,field,value):
 1077:         """get value"""
 1078: 	
 1079: 	if not hasattr(self,'metaDataHash'):
 1080: 		setattr(self,'metaDataHash',{})
 1081: 	self.metaDataHash[field]=value[0:]
 1082: 	
 1083: 
 1084:     def copySearchFields(self):
 1085: 	    """copys metadatafields to the object"""
 1086: 	    fields=['author','title','year']
 1087: 	    for field in fields:
 1088: 		    setattr(self,'MD_'+field,self.getFieldValue(field))
 1089:     
 1090: 
 1091:     def findLabelsFromMapping(self,referenceType):
 1092:         """gib hash mit label -> generic zurueck"""
 1093: 	#return {},[]
 1094: 
 1095:         temp=self.ZopeFind(self.standardMD)
 1096: 
 1097: 	if referenceType=="":
 1098: 		referenceType="book"
 1099: 	
 1100: 	
 1101:         bibdata={}
 1102:         retdata={}
 1103: 	fields=[]
 1104:         fieldlist=self.standardMD.fieldList
 1105:         
 1106: 	for referenceTypeF in self.referencetypes:
 1107: 
 1108: 		if referenceTypeF[1].title.lower() == referenceType.lower():
 1109: 
 1110: 			try:
 1111: 				bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
 1112: 				referenceType=referenceTypeF[1].title
 1113: 			except:
 1114: 				bibdata[referenceType]=referenceTypeF[1].fields
 1115: 		
 1116: 
 1117: 			bibdata['data']=referenceTypeF[1]
 1118: 			fields=bibdata[referenceType]
 1119:                         for field in fieldlist:
 1120:                             retdata[field]=referenceTypeF[1].getValue(field)[1]
 1121: 
 1122:         return retdata,fieldlist,temp,fields
 1123: 
 1124:     def findTagsFromMapping(self,referenceType):
 1125:         """gib hash mit label -> generic zurueck"""
 1126: 	
 1127: 
 1128: 	if referenceType=="":
 1129: 		referenceType="book"
 1130: 	
 1131: 	temp =  self.ZopeFind(self.standardMD)[0:]
 1132: 
 1133: 	
 1134: 	#self.referencetypes=temp[0:]
 1135: 	
 1136: 	
 1137: 	
 1138: 
 1139: 	
 1140: 
 1141:         bibdata={}
 1142:         retdata={}
 1143:         fieldlist=self.standardMD.fieldList
 1144:         fields=[]
 1145: 	for referenceTypeF in temp:
 1146: 		#print referenceType
 1147: 	
 1148: 		if referenceTypeF[1].title.lower() == referenceType.lower(): 
 1149: 			try:
 1150: 				bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
 1151: 				referenceType=referenceTypeF[1].title
 1152: 			except:
 1153: 				bibdata[referenceType]=referenceTypeF[1].fields
 1154: 			bibdata['data']=referenceTypeF[1]
 1155: 			fields=bibdata[referenceType]
 1156:                         for field in fieldlist:
 1157:                             retdata[field]=referenceTypeF[1].getValue(field)[0]
 1158: 	
 1159:         return retdata,fieldlist,temp,fields
 1160: 
 1161:     
 1162:     security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination
 1163:     def copyIndex_meta2echo_resource(self,RESPONSE=None):
 1164: 	    """copy MD von Index_meta to the echo_resource"""
 1165: 	    
 1166: 	    (metadict, error)=readMetadata(self.metalink)
 1167: 
 1168: 
 1169: 	    
 1170: 	    self.metaDataHash={}
 1171: 	    if not error=="": #Fehler beim Auslesen des Metafiles
 1172: 		    
 1173: 		    return "ERROR:",error,self.absolute_url()
 1174: 	    
 1175: 	    self.contentType=metadict['bib_type'][0:]
 1176: 	    fields=self.findTagsFromMapping(self.contentType)
 1177: 	    
 1178: 	    #fields=self.findLabelsFromMapping(self.contentType)
 1179: 	    for field in fields[1]:
 1180: 		    
 1181: 		    if self.isDefinedInThisSet(fields,field):
 1182: 			    #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))
 1183: 			    self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))
 1184: 
 1185: 	    
 1186: 	    
 1187: 	    if RESPONSE:
 1188: 		    return RESPONSE.redirect('manage_main')
 1189: 	    
 1190:     def ECHO_getResourceMD(self,template="yes",back=None):
 1191:         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
 1192:         (metadict, error)=readMetadata(self.metalink)
 1193: 
 1194:         if back:
 1195:             self.REQUEST.SESSION['back']=back
 1196: 
 1197:         if not error=="": #Fehler beim Auslesen des Metafiles
 1198: 		return "ERROR:",error
 1199: 	
 1200: 
 1201: 	if not (metadict['bib_type'].lower()==self.contentType.lower()):
 1202: 		self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
 1203: 		self.REQUEST.SESSION['contentZope']=self.contentType
 1204: 
 1205: 		return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
 1206: 
 1207: 	self.REQUEST.SESSION['metadict']=metadict
 1208: 
 1209: 	
 1210: 	
 1211: 	self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])
 1212: 	
 1213: 
 1214: 		
 1215:         if template=="yes":
 1216: 		pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')
 1217: 		return pt()
 1218: 
 1219: 	
 1220: 
 1221:     
 1222:     
 1223:     def ECHO_getMD(self,item):
 1224:         """Ausgabe der MD"""
 1225:         return getattr(self,item)
 1226: 
 1227:     def checkRDF(self,path):
 1228: 	    """check if pdf in the path"""
 1229: 	    try:
 1230: 		    for fileName in os.listdir(path):
 1231: 			    if os.path.splitext(fileName)[1]==".pdf":
 1232: 				    return os.path.join(path,fileName)
 1233: 		    return None
 1234: 	    except:
 1235: 		    return None
 1236: 	    
 1237: 	    
 1238:     def index_html(self):
 1239:         """standard page"""
 1240:         pdf=self.checkRDF(self.link)
 1241: 	if pdf:
 1242: 		fh=file(pdf,'r').read()
 1243: 		self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')
 1244: 		self.REQUEST.RESPONSE.write(fh)
 1245: 		self.REQUEST.RESPONSE.close()
 1246: 		return 
 1247:         return self.REQUEST.RESPONSE.redirect(self.link)
 1248: 
 1249:     def startpage_html(self):
 1250: 	    """prints out a startpage for a resource for use e.g. in the BVE"""
 1251: 
 1252: 	    # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt
 1253: 
 1254: 	    sp=self.ZopeFind(self,obj_ids=['startpage.html'])
 1255: 
 1256: 	    if sp:
 1257: 		    return sp[1]()
 1258: 
 1259:             #pruefen ob irgendwo ein template
 1260: 	    if hasattr(self,'startpage_index_template'): 
 1261: 		    return self.startpage_index_template()
 1262: 
 1263: 	    #generisches template ausgeben
 1264: 	    
 1265: 	    pt=zptFile(self, 'zpt/ECHO_startpage_index_template_standard.zpt')
 1266: 	    pt.content_type="text/html"
 1267: 	    return pt()
 1268: 
 1269:     def toc_html(self):
 1270: 	    
 1271: 	    sp=self.ZopeFind(self,obj_ids=['toc.html'])
 1272: 		    
 1273: 	    if sp:
 1274: 		    return sp[0][1]()
 1275: 
 1276: 
 1277:     security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
 1278: 
 1279:     def generate_label(self):
 1280:         """Erzeugt_standard_Label aus Template"""
 1281:         pt=getattr(self,"label_template_"+self.contentType.lower())
 1282: 
 1283: 	self.label=pt()[0:]
 1284:         return pt()
 1285: 
 1286:     security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination
 1287: 
 1288:     def generate_title(self,RESPONSE=None):
 1289:         """Erzeugt_standard_Label aus Template"""
 1290:         pt=getattr(self,"label_template_"+self.contentType.lower())
 1291: 
 1292: 	self.title=pt()[0:]
 1293: 	
 1294:         return pt()
 1295: 
 1296: Globals.InitializeClass(ECHO_resource)
 1297: 
 1298: def manage_addECHO_resourceForm(self):
 1299:         """Form for adding a ressource"""
 1300:         pt=zptFile(self, 'zpt/AddECHO_resourceForm.zpt')
 1301:         return pt()
 1302: 
 1303: 
 1304: 
 1305: 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):
 1306:     """addaresource"""
 1307: 
 1308:     newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
 1309: 
 1310:     self._setObject(id,newObj)
 1311: 
 1312:     if RESPONSE is not None:
 1313:         RESPONSE.redirect('manage_main')
 1314:  
 1315: 
 1316: class ECHO_externalLink(Folder,ECHO_basis):
 1317:     """Link zu einer externen Ressource"""
 1318:     security=ClassSecurityInfo()
 1319:     meta_type='ECHO_externalLink'
 1320: 
 1321: 
 1322:     def content_html(self):
 1323:         """template fuer content"""
 1324:         return ECHO_basis.content_html(self,'externalLink')
 1325:     
 1326:     def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
 1327: 
 1328:         self.id = id
 1329:         """Festlegen der ID"""
 1330: 
 1331:         self.credits=toList(credits)
 1332:         self.label = label
 1333:         self.link= link
 1334:         self.title=title
 1335:         self.weight=weight
 1336:         self.description=description
 1337:         self.contentType=contentType
 1338:         self.responsible=responsible
 1339:         coordsnew=[ string.split(x,",") for x in coords]
 1340:         self.coords=coordsnew
 1341: 
 1342:     def ECHO_externalLink_config(self):
 1343:         """Main configuration"""
 1344: 
 1345:         if not hasattr(self,'weight'):
 1346:             self.weight=""
 1347:         if not hasattr(self,'coords'):
 1348:             
 1349:             self.coords=['']
 1350: 
 1351: 
 1352:         pt=zptFile(self, 'zpt/ChangeECHO_externalLink.zpt')
 1353:         return pt()
 1354:     
 1355: 
 1356:     def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
 1357:         """Aenderung der Properties"""
 1358:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
 1359: 
 1360:         self.link=link
 1361:         if RESPONSE is not None:
 1362:             RESPONSE.redirect('manage_main')
 1363:             
 1364:             
 1365:     manage_options = Folder.manage_options+(
 1366:         {'label':'Main Config','action':'ECHO_externalLink_config'},
 1367:         )
 1368: 
 1369:         
 1370:     def index_html(self):
 1371:         """standard page"""
 1372:         
 1373:         return self.REQUEST.RESPONSE.redirect(self.link)
 1374: 
 1375: def manage_addECHO_externalLinkForm(self):
 1376:         """Form for external Links"""
 1377:         pt=zptFile(self, 'zpt/AddECHO_externalLinkForm.zpt')
 1378:         return pt()
 1379: 
 1380: 
 1381: def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
 1382:     """Add an external Link"""
 1383: 
 1384:     newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)
 1385: 
 1386:     self._setObject(id,newObj)
 1387: 
 1388:     if RESPONSE is not None:
 1389:         RESPONSE.redirect('manage_main')
 1390:  
 1391: 
 1392: class ECHO_link(ECHO_externalLink):
 1393: 	"""external_link"""
 1394: 
 1395: 	meta_type="ECHO_link"
 1396: 	
 1397: 
 1398: 	def content_html(self):
 1399: 		"""template fuer link"""
 1400: 		if hasattr(self,"link_template"):
 1401: 			return ECHO_basis.content_html(self,'link')
 1402: 		else:
 1403: 			return ECHO_basis.content_html(self,'collection')
 1404: 	
 1405: def manage_addECHO_linkForm(self):
 1406:         """Form for external Links"""
 1407:         pt=zptFile(self, 'zpt/AddECHO_linkForm.zpt')
 1408:         return pt()
 1409: 
 1410: 
 1411: def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
 1412:     """Add an external Link"""
 1413: 
 1414:     newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)
 1415: 
 1416:     self._setObject(id,newObj)
 1417: 
 1418:     if RESPONSE is not None:
 1419:         RESPONSE.redirect('manage_main')
 1420: 	
 1421: 
 1422: class ECHO_collection(Folder, Persistent, Implicit, Cacheable,ECHO_basis):
 1423:     """ECHO Collection"""
 1424: 
 1425:     security=ClassSecurityInfo()
 1426:     meta_type='ECHO_collection'
 1427: #    viewClassificationList=viewClassificationListMaster
 1428:     displayTypes=displayTypes
 1429: 
 1430:     path="/mpiwg/online/permanent/shipbuilding"
 1431: 
 1432:     def getRDF(self,urn=None):
 1433: 	    """rdf of the collection"""
 1434: 	    
 1435: 	    contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
 1436: 
 1437: 	    ret=getRDFDescription(self,self.absolute_url(),urn=urn)
 1438: 	    
 1439: 	    if not urn:
 1440: 		    urn=self.absolute_url()
 1441: 		    
 1442: 	    li="""<RDF:li RDF:resource="%s" />\n"""
 1443: 
 1444: 	    
 1445: 	    for content in contents:
 1446: 		    ret+=content[1].getRDF()+"\n"
 1447: 		    
 1448: 	    ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
 1449: 	    for content in contents:
 1450: 		    nurn=content[1].absolute_url()
 1451: 		    ret+=li%nurn
 1452: 	    return ret+"</RDF:Seq>"
 1453: 	    
 1454: 
 1455:     
 1456:     def changeLabels(self):
 1457: 		"""change form"""
 1458: 		pt=zptFile(self, 'zpt/changeLabelsForm')
 1459: 		pt.content_type="text/html"
 1460: 		return pt()
 1461: 
 1462:     def changeTitles(self):
 1463: 		"""change form"""
 1464: 		pt=zptFile(self, 'zpt/changeTitleForm')
 1465: 		pt.content_type="text/html"
 1466: 		return pt()
 1467: 
 1468:     def changeWeights(self):
 1469: 		"""change form"""
 1470: 		pt=zptFile(self, 'zpt/changeWeightForm')
 1471: 		pt.content_type="text/html"
 1472: 		return pt()
 1473: 
 1474:     def changeMetaDataLinks(self):
 1475: 		"""change form"""
 1476: 		pt=zptFile(self, 'zpt/changeMetaDataLinkForm')
 1477: 		pt.content_type="text/html"
 1478: 		return pt()
 1479:     def changeAccessRightsCollection(self):
 1480: 	    """change"""
 1481: 	    ret=""
 1482: 	    argv=self.REQUEST.form
 1483: 	    
 1484: 	    resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
 1485: 	    for resource in resources:
 1486: 		   
 1487: 		    try:
 1488: 			    ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
 1489: 			    resource[1].changeAccessRightMD(argv[resource[1].getId()])
 1490: 		    except:
 1491: 			    pass
 1492: 	    return ret
 1493: 
 1494:     def changeMetaDataLinkInCollection(self):
 1495: 	    """change all lables of a collection"""
 1496: 	    ret=""
 1497: 	    argv=self.REQUEST.form
 1498: 	    
 1499: 	    resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
 1500: 	    for resource in resources:
 1501: 		   
 1502: 		    try:
 1503: 			    ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
 1504:                             resource[1].metalink=argv[resource[1].getId()][0:]
 1505: 		    except:
 1506: 			    pass
 1507: 	    return ret
 1508: 
 1509:     def changeMetaDataLinkInCollection(self):
 1510: 	    """change all lables of a collection"""
 1511: 	    ret=""
 1512: 	    argv=self.REQUEST.form
 1513: 	    
 1514: 	    resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
 1515: 	    for resource in resources:
 1516: 		   
 1517: 		    try:
 1518: 			    ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
 1519:                             resource[1].metalink=argv[resource[1].getId()][0:]
 1520: 		    except:
 1521: 			    pass
 1522: 	    return ret
 1523: 
 1524:     def changeWeightsInCollection(self):
 1525: 	    """change all lables of a collection"""
 1526: 	    ret=""
 1527: 	    argv=self.REQUEST.form
 1528: 	    
 1529: 	    resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
 1530: 	    for resource in resources:
 1531: 		   
 1532: 		    try:
 1533: 			    ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
 1534:                             resource[1].weight=argv[resource[1].getId()][0:]
 1535: 		    except:
 1536: 			    pass
 1537: 	    return ret
 1538: 
 1539:     def changeTitlesInCollection(self):
 1540: 	    """change all lables of a collection"""
 1541: 	    ret=""
 1542: 	    argv=self.REQUEST.form
 1543: 	    
 1544: 	    resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
 1545: 	    for resource in resources:
 1546: 		   
 1547: 		    try:
 1548: 			    ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
 1549:                             resource[1].title=argv[resource[1].getId()][0:]
 1550: 		    except:
 1551: 			    pass
 1552: 	    return ret
 1553:         
 1554:     def updateCollection(self,RESPONSE=None):
 1555:         """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
 1556:         files=os.listdir(self.path)
 1557: 	ret=""
 1558:         for fileName in files:
 1559:             
 1560:             if fileName:
 1561: 		
 1562: 		tempPath=re.sub("/mpiwg/online","",self.path)
 1563: 		link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"
 1564: 		
 1565: 		metalink=self.path+"/"+fileName+"/index.meta"
 1566:                 try:
 1567: 
 1568: 			#link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"
 1569: 			
 1570: 			newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'generated','book','','','','','','')
 1571: 			self._setObject(fileName,newObj)
 1572:                 
 1573: 			genObj=getattr(self,fileName)
 1574:                         #genObj.createIndexFile()
 1575: 			ret+="OK:"+fileName+"<br/>"
 1576: 		except:
 1577: 			print "ERROR"
 1578: 			ret+="ERROR:"+fileName+"<br/>"
 1579: 
 1580: 	return ret
 1581: 
 1582:         if RESPONSE is not None:
 1583:             RESPONSE.redirect('manage_main')
 1584: 
 1585:     def updateCollectionMD(self,RESPONSE=None):
 1586:         """updateMD"""
 1587:         files=os.listdir(self.path)
 1588:         for fileName in files:
 1589:             if fileName:
 1590:                 genObj=getattr(self,fileName)
 1591:                 genObj.copyIndex_meta2echo_resource()
 1592:                 genObj.generate_title()
 1593: 
 1594:         if RESPONSE is not None:
 1595:             RESPONSE.redirect('manage_main')
 1596: 
 1597: 
 1598: 
 1599:     def changeViewerTemplateSetsForm(self):
 1600: 	    """change the viewer template set"""
 1601: 	    pt=zptFile(self, 'zpt/changeViewerTemplateSet')
 1602:             return pt()
 1603: 
 1604:     def getViewerTemplateSets(self,obj_ids=None,RESPONSE=None):
 1605: 	    """Get the ViewerTemplateSet title for configuration"""
 1606: 	    ret=[]
 1607: 	    
 1608: 	    try:
 1609: 		    viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.
 1610:             
 1611: 		    for viewerTemplateSet in viewerTemplateSets:
 1612: 			    ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))
 1613: 
 1614: 		    return ret
 1615: 		    
 1616: 	    except:
 1617: 		    return [('no ViewerTemplateSetfolders','')]
 1618: 
 1619:     def getTextToolsField(self,name,default=''):
 1620: 	    """Lese viewerTemplateSet der Collection not implemented yet!"""
 1621: 	    
 1622: 	    return default
 1623: 
 1624:             
 1625:     def isSelectedViewerTemplateSet(self,obj,id):
 1626:         """is ausgewaehlt"""
 1627:         
 1628:         if self.REQUEST['viewerTemplateSet']==id:
 1629:             return 1
 1630:         else:
 1631:             return None
 1632: 
 1633:     def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
 1634: 	    """change the templates"""
 1635: 
 1636: 	    resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
 1637: 
 1638: 	    for resource in resources:
 1639: 
 1640: 		    resource[1].changeViewerTemplateSet(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
 1641: 
 1642: 	    if RESPONSE is not None:
 1643: 		    RESPONSE.redirect('manage_main')
 1644: 
 1645: 
 1646:     def setStartpageFolderForm(self):
 1647: 	    """Form for changing the startpage"""
 1648: 
 1649: 	    
 1650: 	    pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPageFolder.zpt')
 1651:             pt.content_type="text/html"
 1652:             return pt()
 1653:     
 1654:     def setStartpageFolder(self,startpage=None,RESPONSE=None):
 1655: 	    """change the templates"""
 1656: 
 1657: 	    resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
 1658: 
 1659: 	    for resource in resources:
 1660: 
 1661: 		    resource[1].setStartPage(startpage)
 1662: 
 1663: 	    if RESPONSE is not None:
 1664: 		    RESPONSE.redirect('manage_main')
 1665: 
 1666:     def copyTitleToInfoXMLFolder(self,RESPONSE=None):
 1667: 	    """copy title into the title field of info.xml
 1668: 	    author and date werden leer!!!
 1669: 	    """
 1670: 
 1671: 	    
 1672: 	    resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
 1673: 	    
 1674:             
 1675: 	    for resource in resources:
 1676: 		    ret,txt=resource[1].copyTitleToInfoXML()
 1677: 		    if (not ret) and RESPONSE:
 1678: 			    RESPONSE.write("error: %s\n"%txt)
 1679: 		    if ret and RESPONSE:
 1680: 			    RESPONSE.write("ok: %s\n"%txt)
 1681: 		    
 1682: 		    #zLOG.LOG("ECHO (copyTitleToInfoXMLFolder)",zLOG.INFO,txt)	 
 1683: 	    if RESPONSE is not None:
 1684: 		    RESPONSE.write("done!\n")
 1685: 		    RESPONSE.close()
 1686: 		    RESPONSE.redirect('manage_main')
 1687: 		    
 1688:     def copySearchFields(self,RESPONSE=None):
 1689: 	    """copys import metadatafields to the object"""
 1690: 	    resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
 1691: 
 1692: 	    for resource in resources:
 1693: 
 1694: 		    resource[1].copySearchFields()
 1695: 
 1696: 	    if RESPONSE is not None:
 1697: 		    RESPONSE.redirect('manage_main')
 1698: 		    
 1699:     def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
 1700: 	    """warning"""
 1701: 	    pt=zptFile(self, 'zpt/reloadMetaDataFromStorageWarning.zpt')
 1702:             pt.content_type="text/html"
 1703:             return pt()
 1704: 
 1705:     def reloadMetaDataFromStorage(self,RESPONSE=None):
 1706: 	    """copy metadata from the storage to ECHO"""
 1707: 
 1708: 	    return reloadMetaDataFromStorage(self,RESPONSE=None)
 1709: 
 1710:     
 1711:     def getPartnerCopyright(self,name,sonst="generic"):
 1712: 		"""gibt generisches copyright eines partners aus, sonst behalte jetzige einsteillung"""
 1713: 		#print "hi",name,sonst
 1714: 		#print getattr(self.partners,name).copyrightType
 1715: 		try:
 1716: 			partner=getattr(self.partners,name)
 1717: 			return partner.copyrightType
 1718: 		except:
 1719: 			print "error"
 1720: 			return sonst
 1721: 
 1722:     def partnerSelector_HTML(self,selected=None):
 1723:          """give type selector"""
 1724: 	 if not selected:
 1725: 		 retStr="<option selected>\n"
 1726: 	 else:
 1727: 		 retStr="<option>\n"
 1728: 		 
 1729: 	 try: # erste version copyrightTypes exists
 1730: 		 for partner in self.credits:
 1731: 			 if selected and (partner==selected):
 1732: 				 retStr+="""<option selected value="%s">%s\n"""%(partner,partner)
 1733: 			 else:                
 1734: 				 retStr+="""<option value="%s">%s\n"""%(partner,partner)
 1735: 	 except:
 1736: 		 """nothing"""
 1737: 	 return retStr
 1738:  
 1739: #    def getViewClassification(self):
 1740: #        if hasattr(self,'viewClassification'):
 1741: #            return self.viewClassification
 1742: #        else:
 1743: #            return ""
 1744: 
 1745: 	
 1746:     def createRessourcesFromXMLForm(self):
 1747: 	    """form"""
 1748: 	    pt=zptFile(self, 'zpt/createRessourcesFromXMLForm.zpt')
 1749: 	    return pt()
 1750: 
 1751:     def createRessourcesFromXML(self,fileupload):
 1752: 	    """read an XML file for generating resources"""
 1753: 	    dom=xml.dom.minidom.parse(fileupload)
 1754: 	    ret="<h2>Added</h2>"
 1755: 	    for resource in dom.getElementsByTagName('resource'):
 1756: 		    link=getText(resource.getElementsByTagName('link')[0].childNodes)
 1757: 		    label=getText(resource.getElementsByTagName('label')[0].childNodes)
 1758: 		    #splitted=link.split("?")[0].split("/")
 1759: 		    #id=splitted[len(splitted)-1].encode('ascii')
 1760: 		    id=re.sub(" ","_",label).encode('ascii')
 1761: 		    
 1762: 		    ret+="<p>"+label+"</p>"
 1763: 		    manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","")
 1764: 	    return ret
 1765:     
 1766:     def getImageTag(self):
 1767:         """GetTag"""
 1768:         try:
 1769:             return self.imageTag
 1770:         except:
 1771:             return ""
 1772: 
 1773:     def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
 1774:         """SSS"""
 1775:         try:
 1776:             manage_addECHO_resource(self,id,title,label,description,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
 1777:             return "done"
 1778:         except:
 1779:             return None
 1780: 
 1781:     def getSecondaryLink(self):
 1782:         """secondary link"""
 1783:         try:
 1784:             return self.secondaryLink
 1785:         except:
 1786:             return ""
 1787: 
 1788:     def getSecondaryLinkTitle(self):
 1789:         """secondary link"""
 1790:         try:
 1791:             return self.secondaryLinkTitle
 1792:         except:
 1793:             return ""
 1794:         
 1795:     def getCollectionTreeXML(self):
 1796:         """Tree as XML"""
 1797: 
 1798: 	def addPassWd(str):
 1799: 		"""adds a user/passwd to an url"""
 1800: 		txt2=re.sub(r"(http://)(.*?)","\g<1>www:3333@\g<2>",str)
 1801: 		return txt2
 1802: 
 1803:         def getCollection(object,depth=0):
 1804:             depth+=1
 1805:             collections=""
 1806:             for entry in object.__dict__.keys():
 1807:                 element=getattr(object,entry)
 1808:                 try:
 1809:                     if element.meta_type in ["ECHO_collection","ECHO_group"]:
 1810:                         collections+="<element name=\""+urllib.quote(element.title)+"\" url=\""+addPassWd(element.absolute_url())+"\">"
 1811:                         collections+=getCollection(element,depth)+"</element>\n"
 1812:                 except:
 1813:                     """nothing"""
 1814:             return collections
 1815:         
 1816: 	ret="""<?xml version="1.0" encoding="utf-8" ?>"""
 1817:         return ret+"<collection>"+getCollection(self)+"</collection>"
 1818:     
 1819:     def createAllJSAreas(self):
 1820:         """create area calls for JavaScript"""
 1821:         areas = self.getAllMapAreas()
 1822: 	return self.createJSAreas(areas)
 1823: 
 1824:     security.declarePublic('getCreditObject')
 1825:     def getCreditObject(self,name):
 1826:         """credit id to credititem"""
 1827:         try:
 1828:             return getattr(self.partners,name)
 1829:         except:
 1830:             return ""
 1831: 
 1832:     security.declarePublic('ECHO_generateNavBar')
 1833:     def ECHO_generateNavBar(self):
 1834:         """Erzeuge Navigationsbar"""
 1835:         link=""
 1836:         object="self"
 1837:         ret=[]
 1838:         path=self.getPhysicalPath()
 1839:         for element in path:
 1840:             
 1841:            
 1842:             if not element=="":
 1843:                 object+="."+element
 1844:                 
 1845:                 label=eval(object).label
 1846:                 link+="/"+element
 1847:                 if not label=="":
 1848:                     ret.append((label,link))
 1849:         return ret
 1850:     
 1851: 
 1852:     def ECHO_rerenderLinksMDWarning(self):
 1853: 		"""change form"""
 1854: 		pt=zptFile(self, 'zpt/rerenderLinksWarning')
 1855: 		pt.content_type="text/html"
 1856: 		return pt()
 1857: 
 1858: 
 1859:     
 1860:     security.declarePublic('ECHO_rerenderLinksMD')
 1861:     def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
 1862:         """Rerender all Links"""
 1863: 	return ECHO_rerenderLinksMD(self,obj,types)
 1864: 
 1865: 	
 1866:     def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):
 1867: 
 1868:         self.id = id
 1869:         """Festlegen der ID"""
 1870:         self.credits=toList(credits)
 1871:         self.label = label
 1872:         self.title=title
 1873:         self.description=description
 1874:         self.contentType=contentType
 1875:         self.responsible=responsible
 1876:         self.imageTag=imageTag
 1877:         self.weight=weight
 1878:         self.sortfield=sortfield
 1879:         coordsnew=[ string.split(x,",") for x in coords]
 1880:         self.coords=coordsnew
 1881:         self.secondaryLinkTitle=secondaryLinkTitle
 1882:         self.secondaryLink=secondaryLink
 1883: 	self.bgcolour=bgcolour
 1884:         
 1885: 
 1886:     manage_options = Folder.manage_options+ Cacheable.manage_options+(
 1887:         {'label':'Main Config','action':'ECHO_collection_config'},
 1888:         {'label':'Change Labels','action':'changeLabels'},
 1889:         {'label':'Change Titles','action':'changeTitles'},
 1890: 	{'label':'Change Weights','action':'changeWeights'},
 1891:         {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},
 1892:         {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
 1893: 	{'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
 1894: 	{'label':'Set Startpage','action':'setStartpageFolderForm'},
 1895:         {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},
 1896: 	{'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
 1897: 	{'label':'ImportCollection','action':'updateCollection'},
 1898: 	{'label':'Copy MD for indexing and search','action':'copySearchFields'},
 1899:         )
 1900: 
 1901:     
 1902:     security.declarePublic('ECHO_collection_config')
 1903:     def ECHO_collection_config(self):
 1904:         """Main configuration"""
 1905: 
 1906:         if not hasattr(self,'weight'):
 1907:             self.weight=""
 1908: 
 1909:         if not hasattr(self,'sortfield'):
 1910:             self.sortfield="weight"
 1911:   
 1912:         pt=zptFile(self, 'zpt/ChangeECHO_collection.zpt')
 1913:         return pt()
 1914: 
 1915: 
 1916:     def getBgcolour(self):
 1917: 	    """colour"""
 1918: 	    if hasattr(self,'bgcolour') and not (self.bgcolour==""):
 1919: 		    return self.bgcolour
 1920: 	    else:
 1921: 		    return "#dddddd"
 1922: 
 1923: 		
 1924:     security.declarePublic('changeECHO_collection')	    
 1925:     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):
 1926:         """Aenderung der Properties"""
 1927: 
 1928:         self.secondaryLink=secondaryLink
 1929:         self.secondaryLinkTitle=secondaryLinkTitle
 1930:         self.imageTag=imageTag
 1931: 	self.bgcolour=bgcolour
 1932:         self.location=location
 1933: 	self.isAlwaysClickable=isAlwaysClickable
 1934:             
 1935:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
 1936: 		
 1937:         self.sortfield=sortfield
 1938: 
 1939:         if RESPONSE is not None:
 1940:             RESPONSE.redirect('manage_main')
 1941:             
 1942:     def setAlwaysClickable(self,flag="yes"):
 1943: 	    """set clickable"""
 1944: 	    if flag=="yes":
 1945: 		    self.isAlwaysClickable="yes"
 1946: 	    else:
 1947: 		    self.isAlwaysClickable=None
 1948: 
 1949: 	    return flag
 1950:     
 1951:     def showOverview(self):
 1952:         """overview"""
 1953:         if 'ECHO_overview.html' in self.__dict__.keys():
 1954:             return getattr(self,'ECHO_overview.html')()
 1955:         pt=zptFile(self, 'zpt/ECHO_content_overview.zpt')
 1956:         return pt()
 1957: 
 1958:     security.declareProtected('View','index_html')
 1959:     
 1960:     def index_html(self):
 1961:         """standard page"""
 1962:         if self.ZCacheable_isCachingEnabled():
 1963:             
 1964:             result = self.ZCacheable_get()
 1965:             if result is not None:
 1966:                 # Got a cached value.
 1967:                 return result
 1968: 	
 1969:         if 'index.html' in self.__dict__.keys():
 1970:             ret=getattr(self,'index.html')()
 1971:         
 1972:         elif 'overview' in self.__dict__.keys():
 1973:             ret=self.showOverview()
 1974:         elif hasattr(self,'collection_index_template'):
 1975:             ret=self.collection_index_template()    
 1976:         elif hasattr(self,'main_index_template'):
 1977:             ret=self.main_index_template()    
 1978:         else:
 1979: 	    pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')
 1980: 	    pt.content_type="text/html"
 1981: 	    ret=pt.render()
 1982: 
 1983: 	self.ZCacheable_set(ret)
 1984:         return ret
 1985: 
 1986:     def content_html(self,**argv):
 1987:         """template fuer content"""
 1988: 	#print "NN",argv
 1989:         return ECHO_basis.content_html(self,'collection')
 1990:     
 1991:     def getCredits(self):
 1992:         """Ausgabe der credits"""
 1993:         if self.credits:
 1994:             return self.credits
 1995:         else:
 1996:             return []
 1997: 
 1998:     def area_img(self):
 1999:         """area image"""
 2000: 	bt = BrowserCheck(self)
 2001: 	if bt.isIE or bt.isN4:
 2002: 	    return sendFile(self, 'images/red.gif', 'image/gif')
 2003: 	else:
 2004: 	    return sendFile(self, 'images/reda.png', 'image/png')
 2005: 
 2006:     def trans_img(self):
 2007:         """empty image"""
 2008:         return sendFile(self, 'images/trans.gif', 'image/gif')
 2009: 
 2010:     def hl_lib_js(self):
 2011:         """javascript"""
 2012:         return sendFile(self, 'js/hl_lib.js', 'text/plain')
 2013: 
 2014:     def js_lib_js(self):
 2015:         """javascript -- old name"""
 2016:         return sendFile(self, 'js/baselib.js', 'text/plain')
 2017: 
 2018:     def baselib_js(self):
 2019:         """javascript"""
 2020:         return sendFile(self, 'js/baselib.js', 'text/plain')
 2021: 
 2022:     def hl_add_js(self):
 2023:         """javascript"""
 2024:         return sendFile(self, 'js/hl_add.js', 'text/plain')
 2025: 
 2026:     def getAllMapAreas(self):
 2027:         """Give list of coordinates"""
 2028:         mapColTypes=['ECHO_collection','ECHO_resource']
 2029:         areas=[]
 2030:         for entry in self.getSubCols(self,subColTypes=mapColTypes):
 2031:             object=entry
 2032: 	    areas.extend(object.getMapAreas())
 2033:         return areas
 2034:     
 2035: 
 2036:     def deleteMapAreas(self):
 2037: 	"""deletes all map areas from this object"""
 2038: 	for obs in self.ZopeFind(self, obj_metatypes=['MapArea'], search_sub=1):
 2039: 	    ob = obs[1]
 2040: 	    id = ob.id
 2041: 	    parent = ob.aq_parent
 2042: 	    print "deleting: ", ob.id
 2043: 	    parent._delObject(id)
 2044: 	return "Done"
 2045: 
 2046: 
 2047:     getSubCols = ECHO_helpers.getSubCols
 2048: 
 2049: Globals.InitializeClass(ECHO_collection)
 2050:     
 2051: def manage_addECHO_collectionForm(self):
 2052:         """Add collection form"""
 2053:         pt=zptFile(self, 'zpt/AddECHO_collectionForm.zpt')
 2054:         return pt()
 2055: 
 2056: 
 2057: def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
 2058:     """add a echo collection"""
 2059:     
 2060: 
 2061:     newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
 2062: 
 2063:     self._setObject(id,newObj)
 2064: 
 2065:     if RESPONSE is not None:
 2066:         RESPONSE.redirect('manage_main')
 2067: 
 2068: class ECHO_group(ECHO_collection):
 2069: 	"""ECHO Gruppe"""
 2070: 	security=ClassSecurityInfo()
 2071: 	meta_type="ECHO_group"
 2072: 
 2073: 	manage_options = Folder.manage_options+(
 2074: 		{'label':'Main Config','action':'ECHO_group_config'},
 2075: 		{'label':'Rerender Links','action':'ECHO_rerenderLinksMDWarning'},
 2076: 		{'label':'Graphic Coords','action':'ECHO_graphicEntry'},
 2077: 		)
 2078: 	
 2079: 	security.declareProtected('View','index_html')
 2080: 
 2081: 
 2082: 	def getRDF(self,urn=None):
 2083: 	    """rdf of the collection"""
 2084: 	    contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
 2085: 
 2086: 	    ret=getRDFDescription(self,self.absolute_url(),urn=urn)
 2087: 
 2088: 	    
 2089: 	    if not urn:
 2090: 		    urn=self.absolute_url()
 2091: 	    li="""<RDF:li RDF:resource="%s" />\n"""
 2092: 	    
 2093: 	    
 2094: 	    for content in contents:
 2095: 		    ret+=content[1].getRDF()+"\n"
 2096: 		    
 2097: 	    ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
 2098: 	    for content in contents:
 2099: 		    nurn=content[1].absolute_url()
 2100: 		    ret+=li%nurn
 2101: 	    return ret+"</RDF:Seq>"
 2102: 	    
 2103: 	def index_html(self):
 2104: 		"""standard page"""
 2105: 		displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
 2106: 		#if (len(displayedObjects)==1) and (displayedObjects[0][1].meta_type=="ECHO_collection"): # nur ein Object dann redirect auf dieses Object
 2107: 		#	return self.REQUEST.RESPONSE.redirect(displayedObjects[0][1].absolute_url())
 2108: 		
 2109: 		if 'index.html' in self.__dict__.keys():
 2110: 			return getattr(self,'index.html')()
 2111: 		
 2112: 		elif 'overview' in self.__dict__.keys():
 2113: 			return self.showOverview()
 2114: 		elif hasattr(self,'group_index_template'):
 2115: 			return self.group_index_template()
 2116: 		elif hasattr(self,'collection_index_template'):
 2117: 			return self.collection_index_template()    
 2118: 		elif hasattr(self,'main_index_template'):
 2119: 		    return self.main_index_template()    
 2120: 
 2121: 		pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')
 2122: 		pt.content_type="text/html"
 2123: 		return pt()
 2124: 
 2125: 	def ECHO_group_config(self):
 2126: 		"""Main configuration"""
 2127: 		
 2128: 		if not hasattr(self,'weight'):
 2129: 			self.weight=""
 2130: 			
 2131: 		if not hasattr(self,'sortfield'):
 2132: 			self.sortfield="weight"
 2133: 				
 2134: 		if not hasattr(self,'coords'):
 2135: 			self.coords=[]
 2136: 
 2137: 		pt=zptFile(self, 'zpt/ChangeECHO_group.zpt')
 2138: 		return pt()
 2139: 
 2140: 	def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
 2141: 		"""Aenderung der Properties"""
 2142: 
 2143: 		self.secondaryLink=secondaryLink
 2144: 		self.secondaryLinkTitle=secondaryLinkTitle
 2145: 		self.imageTag=imageTag
 2146: 		self.bgcolour=bgcolour
 2147:                 self.logo=logo
 2148:                 
 2149: 		setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
 2150: 
 2151: 
 2152: 
 2153: 		self.sortfield=sortfield
 2154: 
 2155: 		if RESPONSE is not None:
 2156: 		    RESPONSE.redirect('manage_main')
 2157: 
 2158: 	def getLogo(self):    
 2159: 		"""logo ausgeben"""
 2160:                 try:
 2161:                     return self.logo
 2162:                 except:
 2163:                     return "ECHO_groups"
 2164: 
 2165: 	def content_html(self):
 2166: 		"""template fuer content"""
 2167: 		return ECHO_basis.content_html(self,'group')
 2168:     
 2169: 
 2170: 
 2171: def manage_addECHO_groupForm(self):
 2172:         """Add group form"""
 2173:         pt=zptFile(self, 'zpt/AddECHO_groupForm.zpt')
 2174:         return pt()
 2175: 
 2176: 
 2177: def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
 2178:     """add a echo group"""
 2179:     
 2180: 
 2181:     newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
 2182: 
 2183:     setattr(newObj,'logo',logo)
 2184:     self._setObject(id,newObj)
 2185:     
 2186:     if RESPONSE is not None:
 2187:         RESPONSE.redirect('manage_main')
 2188: 
 2189: Globals.InitializeClass(ECHO_group)
 2190: 
 2191: 
 2192: class ECHO_userFolder(UserFolder):
 2193: 	"""User folder for Intranet"""
 2194: 	_domain_auth_mode=1 # Identification via domain
 2195: 	meta_type="ECHO_userFolder"
 2196: 	
 2197: 	def authenticate(self, name, password, request):
 2198: 		emergency = self._emergency_user
 2199: 		if name is None:
 2200: 		    return None
 2201: 		if emergency and name==emergency.getUserName():
 2202: 		    user = emergency
 2203: 		else:
 2204: 		    user = self.getUser(name)
 2205: 		if user is not None and user.authenticate(password, request):
 2206: 		    return user
 2207: 		else:
 2208: 		    return None
 2209: 
 2210: 	def domainSpecMatch(self,spec, request):
 2211: 	    host=''
 2212: 	    addr=''
 2213: 
 2214: 	    # Fast exit for the match-all case
 2215: 	    if len(spec) == 1 and spec[0] == '*':
 2216: 		return 1
 2217: 
 2218: 	    if request.has_key('REMOTE_HOST'):
 2219: 		host=request['REMOTE_HOST']
 2220: 
 2221: 	    if request.has_key('REMOTE_ADDR'):
 2222: 		addr=request['REMOTE_ADDR']
 2223: 
 2224: 	    if request.has_key('HTTP_X_FORWARDED_FOR'):
 2225: 		addr=request['HTTP_X_FORWARDED_FOR']
 2226: 
 2227: 	    
 2228: 	    if not host and not addr:
 2229: 		return 0
 2230: 
 2231: 	    if not host:
 2232: 		try:    host=socket.gethostbyaddr(addr)[0]
 2233: 		except: pass
 2234: 	    if not addr:
 2235: 		try:    addr=socket.gethostbyname(host)
 2236: 		except: pass
 2237: 
 2238: 
 2239: 	    _host=host.split('.')
 2240: 	    _addr=addr.split('.')
 2241: 	    _hlen=len(_host)
 2242: 	    _alen=len(_addr)
 2243: 
 2244: 	    for ob in spec:
 2245: 		sz=len(ob)
 2246: 		_ob=ob.split('.')
 2247: 		_sz=len(_ob)
 2248: 
 2249: 		mo = addr_match(ob)
 2250: 		if mo is not None:
 2251: 		    if mo.end(0)==sz:
 2252: 			fail=0
 2253: 			for i in range(_sz):
 2254: 			    a=_addr[i]
 2255: 			    o=_ob[i]
 2256: 			    if (o != a) and (o != '*'):
 2257: 				fail=1
 2258: 				break
 2259: 			if fail:
 2260: 			    continue
 2261: 			return 1
 2262: 
 2263: 		mo = host_match(ob)
 2264: 		if mo is not None:
 2265: 		    if mo.end(0)==sz:
 2266: 			if _hlen < _sz:
 2267: 			    continue
 2268: 			elif _hlen > _sz:
 2269: 			    _item=_host[-_sz:]
 2270: 			else:
 2271: 			    _item=_host
 2272: 			fail=0
 2273: 			for i in range(_sz):
 2274: 			    h=_item[i]
 2275: 			    o=_ob[i]
 2276: 			    if (o != h) and (o != '*'):
 2277: 				fail=1
 2278: 				break
 2279: 			if fail:
 2280: 			    continue
 2281: 			return 1
 2282: 	    return 0
 2283: 
 2284: Globals.default__class_init__(ECHO_userFolder)
 2285: 
 2286: 
 2287: 
 2288: def manage_addECHO_userFolder(self,dtself=None,REQUEST=None,**ignored):
 2289:     """add a user folder """
 2290:     f=ECHO_userFolder()
 2291:     self=self.this()
 2292:     try:    self._setObject('acl_users', f)
 2293:     except: return MessageDialog(
 2294:                    title  ='Item Exists',
 2295:                    message='This object already contains a User Folder',
 2296:                    action ='%s/manage_main' % REQUEST['URL1'])
 2297:     self.__allow_groups__=f
 2298:     if REQUEST is not None:
 2299:         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
 2300: 
 2301: def manage_addECHO_userFolderForm(self):
 2302: 	"""add a user folder form"""
 2303: 	return manage_addECHO_userFolder(self)
 2304: 
 2305: 
 2306: 
 2307: def createNode(self,descrs,node):
 2308: 	name=descrs[node]['name']
 2309: 	type=descrs[node]['type']
 2310: 	urn=node
 2311: 	#print "    will create",node.encode('utf-8')
 2312: 	id=re.sub('[^a-zA-Z0-9]','',name).encode('ascii','ignore')
 2313: 	#print "id",id
 2314: 	#print type
 2315: 	#self.REQUEST.RESPONSE.write("<p>%s<p>\n"%id)
 2316: 	if type=="CDLI_group":
 2317: 		
 2318: 		try:
 2319: 			manage_addECHO_collection(self,id,name,name,"","","","","")
 2320: 		
 2321: 		except:
 2322: 			self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
 2323: 			
 2324: 		self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
 2325: 		
 2326: 		return type,getattr(self,id),urn
 2327: 
 2328: 	if type=="CDLI_item":
 2329: 		try:
 2330: 			manage_addECHO_resource(self,id,name,name,"","",urn,"","")
 2331: 		except:
 2332: 			self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
 2333: 		self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
 2334: 		
 2335: 		
 2336: 	return "XX"
 2337: 
 2338: 
 2339: class ECHO_root(Folder,Persistent,Implicit):
 2340:     """ECHO Root Folder"""
 2341: 
 2342:     security=ClassSecurityInfo()
 2343:     
 2344:     meta_type="ECHO_root"
 2345: 
 2346:     # testing templates with macros... ROC
 2347: ##     content_overview_template2 = zptObjectOrFile(None, 'content_overview_template', orphaned=True)
 2348: ##     print "COT: ", content_overview_template2, repr(content_overview_template2)
 2349:     
 2350: ##     def content_overview_template(self):
 2351: ## 	content_overview_template2._cook_check()
 2352: ##	return content_overview_template2()
 2353: 
 2354:     ###Cdli adds -> have to be removed
 2355:     def getTablet(self,item):
 2356:         #print "getTablet"
 2357: 	try:
 2358: 		read=urllib.urlopen("http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"%item).read()
 2359:                 read=re.sub("\[search\]","search",read)
 2360: 		return read[read.find("<body>")+6:read.rfind("</body>")]
 2361: 	except:
 2362: 		return "<h1>Sorry no connection to the data server enlil.museum.upenn.edu</h1>"
 2363: 	#return "http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"
 2364:     ###END CDLI add
 2365: 
 2366: 
 2367:     def URLquote(self, text):
 2368:         """urllib.quote fuer Michael"""
 2369: 	return urllib.quote(text)
 2370: 
 2371: 
 2372:     def checkResource(self,id):
 2373: 	    """checks if a resource is in the tree, gives back none or list of resources"""
 2374: 	    if hasattr(self,"_v_checkResource") and self._v_checkResource.has_key(id): #existiert ein cache und id ist bereits drin?
 2375: 			    return self._v_checkResource[id]
 2376: 
 2377: 	    else:
 2378: 		    resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],obj_ids=[id],search_sub=1)
 2379: 
 2380: 		    if not hasattr(self,"_v_checkResource"): self._v_checkResource={}#lege cache an falls nicht existent
 2381: 		    if resources:
 2382: 			    self._v_checkResource[id]=resources[0:] # slicing to be sure that data is stabil
 2383: 		    else:
 2384: 			    self._v_checkResource[id]=None
 2385: 		    
 2386: 		    return self._v_checkResource[id]
 2387: 	    
 2388:     def sendForm(self,fromaddr,content,server='mail.mpiwg-berlin.mpg.de'):
 2389: 	    """sendform"""
 2390: 	    toaddrs=["dwinter@mpiwg-berlin.mpg.de"]
 2391: 	    
 2392: 	    msg = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n"
 2393: 		   % (fromaddr, ", ".join(toaddrs),"testsub"))
 2394: 	    server = smtplib.SMTP(server)
 2395: 	    #server.set_debuglevel(1)
 2396: 	    msg=msg+content
 2397: 	    server.sendmail(fromaddr, toaddrs, msg)
 2398: 	    server.quit()
 2399: 		 
 2400:     def generateFromRDFForm(self):
 2401: 		"""change form"""
 2402: 		pt=zptFile(self, 'zpt/generateFromRDFForm')
 2403: 		pt.content_type="text/html"
 2404: 		return pt()
 2405: 
 2406:     def generateFromRDF(self,file,startNode="/Cuneiform Corpus"):
 2407: 
 2408: 	    """generate from RDF"""
 2409: 
 2410: 	    global seqs
 2411: 	    seqs={}
 2412: 	    global descrs
 2413: 	    descrs={}
 2414: 	    global key
 2415: 	    key=""
 2416: 	    global value
 2417: 	    value=""
 2418: 
 2419: 	    def getEdges(seqs,urn):
 2420: 		    """edges"""
 2421: 		    ret=[]
 2422: 		    return seqs[urn]
 2423: 
 2424: 	    def createSubs(self,seqs,descrs,urn,level=0):
 2425: 		    """create subs"""
 2426: 		    for edge in getEdges(seqs,urn):
 2427: 			    cn=createNode(self,descrs,edge)
 2428: 			    if cn[0]=="CDLI_group":
 2429: 				    createSubs(cn[1],seqs,descrs,cn[2],level+1)
 2430: 		    return
 2431: 
 2432: 	    def start_element(name,attrs):
 2433: 
 2434: 		    global seqs
 2435: 		    global descrs
 2436: 		    global key
 2437: 		    global value
 2438: 		    seq=""
 2439: 		    if name=="RDF:Seq":
 2440: 			    key=attrs.get('RDF:about')
 2441: 			    try: # teste ob liste
 2442: 				    x=seqs[key][0]
 2443: 			    except:
 2444: 
 2445: 				    seqs[key]=[]
 2446: 
 2447: 		    
 2448: 		    elif name=="RDF:Description":
 2449: 			    key=attrs.get('RDF:about')
 2450: 			    
 2451: 
 2452: 		    elif name=="RDF:li":
 2453: 			    name=attrs.get('RDF:resource')
 2454: 			    seqs[key].append(name)
 2455: 
 2456: 		    elif name=="ECHONAVIGATION:type":
 2457: 			    value="type"
 2458: 
 2459: 		    elif name=="ECHONAVIGATION:name":
 2460: 			    value="name"
 2461: 		    elif name=="ECHONAVIGATION:linkClickable":
 2462: 			    value="linkClickable"
 2463: 			    
 2464: 	    def end_element(name):
 2465: 			    """nothing"""
 2466: 			    key=""
 2467: 			    value=""
 2468: 
 2469: 	    def char_data(data):
 2470: 		    """nothing"""
 2471: 
 2472: 		    data=re.sub("\n","",data)
 2473: 		    try:
 2474: 			    if descrs[key].has_key(value):
 2475: 				    descrs[key][value]+=data
 2476: 			    else:
 2477: 				    descrs[key][value]=data
 2478: 		    except:
 2479: 
 2480: 			    descrs[key]={}
 2481: 			    descrs[key][value]=data
 2482: 			    
 2483: 	    p = xml.parsers.expat.ParserCreate()
 2484: 	    
 2485: 	    p.StartElementHandler = start_element
 2486: 	    p.EndElementHandler = end_element
 2487: 	    p.CharacterDataHandler = char_data
 2488: 	    
 2489: 	    
 2490: 	    p.ParseFile(file)
 2491: 	    self.REQUEST.RESPONSE.write("<html><body><h1>Start</h1>")
 2492: 	    createSubs(self,seqs,descrs,startNode)
 2493: 	    self.REQUEST.RESPONSE.write("<h1>done</h1></body></html>")
 2494: 	    #print "done"
 2495: 
 2496: 	    
 2497: 	    return "done"
 2498:     
 2499: 	    
 2500: 
 2501:    		
 2502:     def changeWeightsInCollection(self):
 2503: 	    """change all lables of a collection"""
 2504: 	    ret=""
 2505: 	    argv=self.REQUEST.form
 2506: 	    
 2507: 	    resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
 2508: 	    for resource in resources:
 2509: 		   
 2510: 		    try:
 2511: 			    ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
 2512:                             resource[1].weight=argv[resource[1].getId()][0:]
 2513: 		    except:
 2514: 			    pass
 2515: 	    return ret
 2516: 
 2517:     def changeWeights(self):
 2518: 		"""change form"""
 2519: 		pt=zptFile(self, 'zpt/changeWeightForm')
 2520: 		pt.content_type="text/html"
 2521: 		return pt()
 2522:     getSubCols = ECHO_helpers.getSubCols
 2523: 
 2524:     manage_options=Folder.manage_options+(
 2525: 		{'label':'Main Config','action':'ECHO_copyright_configForm'},
 2526: 		{'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
 2527: 		{'label':'Change Weights','action':'changeWeights'},
 2528: 		{'label':'Generate from RDF','action':'generateFromRDFForm'},
 2529: 
 2530: )
 2531: 
 2532:     
 2533: 
 2534:     def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
 2535: 	    """warning"""
 2536: 	    pt=zptFile(self, 'zpt/reloadMetaDataFromStorageWarning.zpt')
 2537:             pt.content_type="text/html"
 2538:             return pt()
 2539: 
 2540:     def reloadMetaDataFromStorage(self,RESPONSE=None):
 2541: 	    """reload MD from Storage"""
 2542: 
 2543: 	    return reloadMetaDataFromStorage(self,RESPONSE)
 2544:     
 2545:     def getRDF(self,urn=None):
 2546: 	    """rdf of the collection"""
 2547: 
 2548: 	    contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
 2549: 
 2550: 	    ret=getRDFDescription(self,self.absolute_url(),urn=urn)
 2551: 	    
 2552: 	    li="""<RDF:li RDF:resource="%s" />\n"""
 2553: 
 2554: 	    
 2555: 	    for content in contents:
 2556: 		    ret+=content[1].getRDF()+"\n"
 2557: 		    
 2558: 	    ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
 2559: 	    for content in contents:
 2560: 		    nurn=content[1].absolute_url()
 2561: 		    ret+=li%nurn
 2562: 	    return ret+"</RDF:Seq>"
 2563: 	    
 2564: 
 2565:     def showContent(self,path):
 2566: 	    """return content/html"""
 2567: 	    
 2568: 	    return ECHO_helpers.urlopen(path+"/content_html").read()
 2569:     
 2570:     def getImageViewers(self):
 2571:         """images"""
 2572:         viewers=self.ZopeFind(self.standardImageViewer,obj_metatypes=['OSAS_ViewerObject'])
 2573:         return viewers
 2574:     
 2575: 
 2576:     def getBibTag(self,tag,content):
 2577: 	    """get field tag for index-meta-generation"""
 2578: 	    if not content or content=="":
 2579: 		    return ""
 2580: 	    ret="<%s>"%tag
 2581: 	    #ret+=urllib.quote(content)
 2582: 	    ret+=content
 2583: 
 2584: 	    ret+="</%s>"%tag
 2585: 	    return ret
 2586: 
 2587:     def getValueFromClass(self,field,found):
 2588: 	    """retattribute falss existing"""
 2589: 	    try:
 2590: 		    
 2591: 		    return getattr(found,field).decode('ascii','ignore')
 2592: 	    except:
 2593: 		    return ""
 2594:     
 2595:     def getImageTag(self):
 2596: 	    """needed by main_template"""
 2597: 	    return ""
 2598:     secondaryLink="" #needed by main_template
 2599:     secondaryLinkTitle="" #needed by main_template
 2600:     
 2601:     def getBgcolour(self):
 2602: 	"""hack"""
 2603: 	return "#dddddd"
 2604: 
 2605:     def contentTypeSelector_HTML(self,selected=None):
 2606:         """give type selector"""
 2607:         if not selected:
 2608:             retStr="<option selected>\n"
 2609:         else:
 2610:             retStr="<option>\n"
 2611:             
 2612:         try: # erste version contentTypes exists
 2613:             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):
 2614:                 if selected and (contentType[0]==selected):
 2615:                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
 2616:                 else:                
 2617:                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
 2618:         except:
 2619: 		try:
 2620: 			for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):
 2621: 				if selected and (contentType[0]==selected):
 2622: 					retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
 2623: 				else:                
 2624: 					retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
 2625: 		except:
 2626: 			"""nothing"""
 2627: 			    
 2628: 	return retStr
 2629: 
 2630:     def renderingTypeSelector_HTML(self,selected=None):
 2631:          """give type selector"""
 2632: 	 if not selected:
 2633: 		 retStr="<option selected>\n"
 2634: 	 else:
 2635: 		 retStr="<option>\n"
 2636: 		 
 2637: 	 try: # erste version renderingTypes exists
 2638: 		 for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
 2639: 			 if selected and (renderingType[0]==selected):
 2640: 				 retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
 2641: 			 else:                
 2642: 				 retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
 2643: 	 except:
 2644: 		 """nothing"""
 2645: 	 return retStr
 2646: 
 2647:     def renderingTypeSelector_HTML(self,selected=None):
 2648:          """give type selector"""
 2649: 	 if not selected:
 2650: 		 retStr="<option selected>\n"
 2651: 	 else:
 2652: 		 retStr="<option>\n"
 2653: 		 
 2654: 	 try: # erste version renderingTypes exists
 2655: 		 for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
 2656: 			 if selected and (renderingType[0]==selected):
 2657: 				 retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
 2658: 			 else:                
 2659: 				 retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
 2660: 	 except:
 2661: 		 """nothing"""
 2662: 	 return retStr
 2663: 
 2664: 
 2665:     def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):
 2666:          """give type selector"""
 2667: 
 2668: 	 if not first:
 2669: 		 if not selected:
 2670: 			 retStr="<option selected>\n"
 2671: 		 else:
 2672: 			 retStr="<option>\n"
 2673: 	 else:
 2674: 		 if not selected:
 2675: 			 retStr="""<option selected value="%s">%s\n"""%first
 2676: 		 else:
 2677: 			 retStr="""<option value="%s">%s\n"""%first
 2678: 
 2679: 	 
 2680: 	 try: # erste version copyrightTypes exists
 2681: 		 for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
 2682: 			 if selected and (copyrightType[0]==selected):
 2683: 				 retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
 2684: 			 else:                
 2685: 				 retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
 2686: 		 
 2687: 		 for copyrightTypeSelf in self.ZopeFind(object,obj_metatypes=["ECHO_copyrightType"],search_sub=1):
 2688: 			 if selected and (copyrightTypeSelf[0]==selected):
 2689: 				 retStr+="""<option selected value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
 2690: 			 else:                
 2691: 				 retStr+="""<option value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
 2692: 				 
 2693: 	 except:
 2694: 	     """nothing"""
 2695: 		 
 2696: 	 return retStr
 2697: 
 2698:     def partnerSelector_HTML(self,selected=None):
 2699:          """give type selector"""
 2700: 	 if not selected:
 2701: 		 retStr="<option selected>\n"
 2702: 	 else:
 2703: 		 retStr="<option>\n"
 2704: 		 
 2705: 	 try: # erste version copyrightTypes exists
 2706: 		 for copyrightType in self.ZopeFind(self.partners,obj_metatypes=["ECHO_partner"]):
 2707: 			 if selected and (copyrightType[0]==selected):
 2708: 				 retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
 2709: 			 else:                
 2710: 				 retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
 2711: 	 except:
 2712: 		 """nothing"""
 2713: 	 return retStr
 2714:  
 2715:     mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version ueber echoroot??
 2716: 
 2717:     def mediaTypeSelector_HTML(self,selected=None):
 2718:          """give type selector"""
 2719: 	 if not selected:
 2720: 		 retStr="<option selected>\n"
 2721: 	 else:
 2722: 		 retStr="<option>\n"
 2723: 	 
 2724: 	 try: # erste version mediatypesTypes exists
 2725: 		 for mediaType in self.mediaTypes:
 2726: 			 if selected and (mediaType in selected):
 2727: 				 retStr+="""<option selected value="%s">%s\n"""%(mediaType,mediaType)
 2728: 			 else:                
 2729: 				 retStr+="""<option value="%s">%s\n"""%(mediaType,mediaType)
 2730: 	 except:
 2731: 		 """nothing"""
 2732: 	 return retStr
 2733: 
 2734:             
 2735:     def patchContentType(self,obj=None):
 2736:         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
 2737:     
 2738: 
 2739:         if not obj:
 2740:             obj = self
 2741:             
 2742:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
 2743: 
 2744:         for entry in entries:
 2745:                 setattr(entry[1],'contentType',entry[1].content_type)
 2746:                 #entry[1].contentType == entry[1].content_type
 2747: 
 2748:                 if entry[1].meta_type == 'ECHO_collection':
 2749:                     entry[1].patchContentType(entry[1])    
 2750: 
 2751:                 
 2752:         return "changed all contenttypes in: "+self.title
 2753: 
 2754: 
 2755:     def repairAllCoords(self):
 2756: 	"""updates map coordinates on the same and sublevels"""
 2757: 	return repairCoords(self)
 2758: 
 2759: 
 2760:     def patchViewClassification(self,obj=None):
 2761:         """setze viewClassification heuristisch"""
 2762: 
 2763: 	def checkIfArrow(obj):
 2764: 		if hasattr(obj,'coords'):
 2765: 			for coordtemp in obj.coords:
 2766: 
 2767: 				if (len(coordtemp)>4) and not (coordtemp[4]==''):
 2768: 					return 4
 2769: 			return None
 2770: 		return None
 2771: 	
 2772:         if not obj:
 2773:             obj = self
 2774:             
 2775:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])
 2776: 
 2777:         for entry in entries:
 2778: 		
 2779: 		if checkIfArrow(entry[1]):
 2780: 			setattr(entry[1],'viewClassification','view point')
 2781: 		else:
 2782: 			setattr(entry[1],'viewClassification','area')
 2783: 
 2784:                 #entry[1].contentType == entry[1].content_type
 2785: 
 2786:                 if entry[1].meta_type in ['ECHO_collection','ECHO_group']:
 2787:                     entry[1].patchViewClassification(entry[1])    
 2788: 
 2789:                 
 2790:         return "changed all contenttypes in: "+self.title
 2791: 
 2792:     def deleteCache(self,obj=None,RESPONSE=None):
 2793:         """setze alle collections auf cache = CacheManager"""
 2794:         if not obj:
 2795:             obj = self
 2796:         entries=obj.ZopeFind(obj,search_sub=1)
 2797:         for entry in entries:
 2798: 		if hasattr(entry[1],'_v_hash'):
 2799: 			entry[1]._v_hash=None
 2800:         
 2801:         return "changed all CM in: "+self.title
 2802: 
 2803:     
 2804:     security.declarePublic('ECHO_newViewerLink')
 2805:     def ECHO_newViewerLink(self,obj=None):
 2806:         """change links (:86 faellt weg)"""
 2807: 
 2808:         if not obj:
 2809:             obj = self
 2810:             
 2811:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
 2812: 
 2813:         for entry in entries:
 2814:                 
 2815:                 if entry[1].meta_type == 'ECHO_resource':
 2816:                     
 2817:                     entry[1].link=re.sub('\:86','',entry[1].link)
 2818: 
 2819:                 else:
 2820:                     
 2821:                     entry[1].ECHO_newViewerLink(entry[1])
 2822:                 
 2823:         return "Rerenderd all links to resources in: "+self.title
 2824: 
 2825:     def __init__(self,id,title):
 2826:         """init"""
 2827:         self.id = id
 2828:         self.title=title
 2829: 
 2830:     def deleteSpace(self,str):
 2831:         """delete space at the end of a line"""
 2832:         if str[len(str)-1]==" ":
 2833:             return str[0:len(str)-1]
 2834:         else:
 2835:             return str
 2836:         
 2837:     
 2838: 
 2839:     # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
 2840: 
 2841:     def formatAscii(self,str,url=None):
 2842:         """ersetze ascii umbrueche durch <br>"""
 2843:         #url=None
 2844:         if url:
 2845:             
 2846:             retStr=""
 2847:             words=str.split("\n")
 2848:             
 2849:             for word in words:
 2850:                 strUrl=url%word
 2851: 
 2852:                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
 2853:             str=retStr
 2854:         if str:
 2855:             return re.sub(r"[\n]","<br/>",str)
 2856:         else:
 2857:             return ""
 2858:         
 2859:     def link2html(self,str):
 2860:         """link2html fuer VLP muss hier noch raus"""
 2861:         if str:
 2862: 
 2863:             str=re.sub("\&","&amp;",str)
 2864:             dom=xml.dom.minidom.parseString("<?xml version='1.0' encoding='utf-8'?><txt>"+str+"</txt>")
 2865:             links=dom.getElementsByTagName("link")
 2866:             
 2867: 
 2868:             for link in links:
 2869:                 link.tagName="a"
 2870: 		ref=link.getAttribute("ref")
 2871: 		pn=link.getAttribute("page")
 2872: 			
 2873:                 if self.checkRef(ref):
 2874: 			if pn:
 2875: 				link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref+"&p="+pn)
 2876: 			else:
 2877: 				link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref)
 2878: 
 2879: 
 2880:             newxml=dom.toxml('utf-8')
 2881: 	  
 2882: 	    retStr=regexpTXT.search(newxml)
 2883: 
 2884: 	    return retStr.group(1)
 2885: 
 2886: 			   
 2887:         return ""
 2888: 
 2889:     def xml2html(self,str,quote="yes"):
 2890:         """link2html fuer VLP muss hier noch raus"""
 2891: 
 2892:         if str:
 2893:             if quote=="yes2":
 2894:                 str=re.sub("\&","&amp;",str)
 2895:             #dom=xml.dom.minidom.parseString(str)
 2896: 	    dom = NonvalidatingReader.parseString(str,"http://www.mpiwg-berlin.mpg.de/")
 2897:             #links=dom.getElementsByTagName("link")
 2898:             links=Ft.Xml.XPath.Evaluate(".//link", contextNode=dom)
 2899:             for link in links:
 2900:                 #link.tagName="a"
 2901: 	
 2902:                 ref=link.getAttributeNS(EMPTY_NAMESPACE,"ref")
 2903: 		pn=link.getAttributeNS(EMPTY_NAMESPACE,"page")
 2904: 
 2905: 		cns=link.childNodes[0:]
 2906: 		
 2907: 		newLink=dom.createElementNS(EMPTY_NAMESPACE,"a")
 2908: 		for x in cns:
 2909: 			newLink.appendChild(x)
 2910: 		
 2911: 			
 2912: 		
 2913: 		link.parentNode.replaceChild(newLink,link)
 2914:                 if self.checkRef(ref):
 2915: 			if pn:
 2916: 				newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn)
 2917: 			else:
 2918: 				newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
 2919: 
 2920:             #str= dom.toxml('utf-8')
 2921: 	    buf = cStringIO.StringIO()
 2922: 	    PrettyPrint(dom, stream=buf, encoding='UTF-8')
 2923: 	    str = buf.getvalue()
 2924: 	    buf.close()
 2925: 	    #str=PrettyPrint(dom.documentElement,encoding='UTF-8')
 2926: 	    #print link.toxml('utf-8')
 2927: 	    #print type(str)
 2928: 	    retStr=regexpPage.search(str)
 2929: 	    try: # hack warum fehtl manchmal page??
 2930: 		    return retStr.group(1)
 2931: 	    except:
 2932: 		    return str
 2933:         return ""
 2934: 
 2935:     def checkRef(self,ref):
 2936: 	    if ref[0:3]=='lit':
 2937: 		    if len(self.library_data({ 'id':ref}))>0:
 2938: 			    return 1
 2939: 	    try:
 2940: 		    if ref[0:7]=="tec_cat":
 2941: 			    return 1
 2942: 	    except:
 2943: 		    """nothing"""
 2944: 		    
 2945: 	    dbs={'vl_technology':'','vl_people':'','vl_sites':''}
 2946: 	    res=None
 2947: 	    for db in dbs.keys():
 2948: 		    res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
 2949: 	    return res
 2950:                                     
 2951:     #Ende Methode fuer vlp
 2952: 
 2953:     def PgQuoteString(self,string):
 2954:         """Quote string"""
 2955: 
 2956:         return libpq.PgQuoteString(string)
 2957:         
 2958:     def getPartners(self):
 2959:         """Get list of Partners. Presently only from a subfolder partners"""
 2960: 	if hasattr(self,'partners'):            
 2961: 		return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
 2962: 	else:
 2963: 		return []
 2964:   
 2965:     def getInstitutions(self):
 2966:         """Get list of Partners. Presently only from a subfolder partners"""
 2967:                     
 2968:         return [ item[1] for item in self.institutions.ZopeFind(self.institutions,obj_metatypes=['ECHO_institution'])]
 2969: 
 2970:    
 2971:     def getPartnersXML(self):
 2972:         """partner liste als xml""" 
 2973:         partners=self.getPartners()
 2974:         ret="""<?xml version="1.0" encoding="utf-8" ?>
 2975: 	<partners>"""
 2976:         
 2977: 	for partner in partners:
 2978:             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)
 2979: 
 2980:         return ret+"\n</partners>"
 2981:     
 2982:     def getCollectionTree(self):
 2983:         """get the collection tree (list of triples (parent,child, depth)"""
 2984: 
 2985:         def getCollection(object,depth=0):
 2986:             depth+=1
 2987:             collections=[]
 2988:             for entry in object.__dict__.keys():
 2989:                 element=getattr(object,entry)
 2990:                 try:
 2991:                     if element.meta_type=="ECHO_collection":
 2992:                         collections.append((object,element,depth))
 2993:                         collections+=getCollection(element,depth)
 2994:                 except:
 2995:                     """nothing"""
 2996:             return collections
 2997:         
 2998: 
 2999:         return getCollection(self)
 3000:     
 3001:     def getCollectionTreeIds(self):
 3002:         """Show the IDs of the Tree"""
 3003:         ret=[]
 3004:         for collection in self.getCollectionTree():
 3005:             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
 3006:         return ret
 3007: 
 3008:     def getResourcesHTML(self,viewerType=None,filter=None):
 3009: 	    """gebe all ressourcen aus"""
 3010: 
 3011: 	    def sortHTML(x,y):
 3012: 		    return cmp(x[1].title,y[1].title)
 3013: 	    
 3014: 	    ret="""<html><body><h2>Resources in ECHO</h3>"""
 3015: 	    
 3016: 	    resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
 3017: 	    ret+="""<h3>Found %i resources</h3>"""%len(resources)
 3018: 	    resources.sort(sortHTML)
 3019: 	    for resource in resources:
 3020: 		    echo_url=resource[1].absolute_url()
 3021: 		    
 3022: 		    if hasattr(resource[1],'title'):
 3023: 			    title=resource[1].title
 3024: 		    else:
 3025: 			    title="None"
 3026: 		    if filter:
 3027: 			    if re.search(filter,title):
 3028: 				    ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
 3029: 		    else:
 3030: 			    ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
 3031: 
 3032: 	    ret +="""\n</body></html>"""
 3033: 	    
 3034: 	    #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")
 3035: 	    #self.REQUEST.RESPONSE.write(ret)
 3036:     	    return ret
 3037:     
 3038:     def getResourcesXML(self,viewerType=None,filter=None):
 3039: 	    """gebe all ressourcen aus"""
 3040: 	    ret="""<?xml version="1.0" ?>
 3041: 	             <index>"""
 3042: 	    for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
 3043: 
 3044: 		    echo_url=resource[1].absolute_url()
 3045: 		    if hasattr(resource[1],'link'):
 3046: 			    viewer_url=resource[1].link
 3047: 		    else:
 3048: 			    viewer_url="NO URL"
 3049: 		    if filter:
 3050: 			    if re.search(filter,viewer_url):
 3051: 				    ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
 3052: 		    else:
 3053: 			    ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
 3054: 	    ret +="""\n</index>"""
 3055: 	    
 3056: 	    self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
 3057: 	    self.REQUEST.RESPONSE.write(ret)
 3058: 
 3059:     def getFullTextsXML(self,viewerType=None,filter=None):
 3060: 	    """gebe all ressourcen aus"""
 3061: 	    ret="""<?xml version="1.0" ?>
 3062: 	             <index>"""
 3063: 	    for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
 3064: 
 3065: 		    echo_url=resource[1].absolute_url()
 3066: 		    if resource[1].getFullTextXML(noredirect="yes"):
 3067: 			    if hasattr(resource[1],'link'):
 3068: 				    viewer_url=echo_url+"/getFullTextXML"
 3069: 			    else:
 3070: 				    viewer_url="NO URL"
 3071: 			    if filter:
 3072: 				    if re.search(filter,viewer_url):
 3073: 					    ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
 3074: 			    else:
 3075: 				    ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
 3076: 	    ret +="""\n</index>"""
 3077: 	    
 3078: 	    
 3079: 	    self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
 3080: 	    self.REQUEST.RESPONSE.write(ret)
 3081: 
 3082: 
 3083:     def getMetaDatasXML(self,viewerType=None,filter=None):
 3084: 	    """gebe all ressourcen aus"""
 3085: 	    # check if the request's host part was OK
 3086: 	    http_host = self.REQUEST['HTTP_HOST']
 3087: 	    host_port = self.REQUEST['SERVER_PORT']
 3088: 	    fix_host = None
 3089: 	    if http_host and http_host.rfind(host_port) == -1:
 3090: 		    print "HTTP_HOST needs fixing!"
 3091: 		    fix_host = http_host + ":" + host_port
 3092: 
 3093: 	    ret="""<?xml version="1.0" ?>
 3094: 	             <index>"""
 3095: 	    for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
 3096: 
 3097: 		    echo_url=resource[1].absolute_url()
 3098: 		    if fix_host:
 3099: 			    #print "replacing ", http_host, " by ", fix_host
 3100: 			    echo_url = string.replace(echo_url, http_host, fix_host, 1)
 3101: 		    
 3102: 		    if hasattr(resource[1],'link'):
 3103: 			    meta_url=echo_url+"/getMetaDataXML"
 3104: 		    else:
 3105: 			    meta_url="NO_URL"
 3106: 			    
 3107: 		    if filter and not re.search(filter,viewer_url):
 3108: 			    continue
 3109: 
 3110: 		    #modificationDate=time.strptime(str(resource[1].bobobase_modification_time()),"%Y/%m/%d %H:%M:%S %Z")
 3111: 		    
 3112: 		    modificationDate=resource[1].bobobase_modification_time().strftime("%Y/%m/%d %H:%M:%S")
 3113: 
 3114: 		    ret+="""\n<resource resourceLink="%s" metaLink="%s" modificationDate="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(meta_url,safe='/:?'),modificationDate)
 3115: 		    
 3116: 			    
 3117: 	    ret +="""\n</index>"""
 3118: 
 3119: 	    self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
 3120: 	    self.REQUEST.RESPONSE.write(ret)
 3121: 
 3122: 	    
 3123:     def findPartners(self):	
 3124:         """find all partners in partners"""
 3125:         par=self.ZopeFind(self.partners, obj_metatypes='ECHO_partner')
 3126:         return par
 3127:         
 3128:     def getPartnerFromID(self):
 3129:         """find partner form ID return object"""
 3130:         pa=self.REQUEST['partner']
 3131:         par=self.ZopeFind(self.partners, obj_ids=[pa])
 3132:         return par
 3133:         
 3134:     def getPartnerFromIDParameter(self, id):
 3135:         """ find partners from ID"""
 3136:         par=self.ZopeFind(self.partners, obj_ids=[id])
 3137:         return par
 3138:         
 3139:     def getInstitutionFromID(self,id):
 3140:         """ find institution from id """
 3141:         inst=self.ZopeFind(self.institutions, obj_ids=[id])
 3142:         return inst
 3143: 
 3144:         
 3145: def manage_addECHO_root(self,id,title,RESPONSE=None):
 3146:     """Add an ECHO_root"""
 3147:     self._setObject(id,ECHO_root(id,title))
 3148:     
 3149:     if RESPONSE is not None:
 3150:         RESPONSE.redirect('manage_main')
 3151: 
 3152: def manage_addECHO_rootForm(self):
 3153:         """Nothing yet"""
 3154:         pt=zptFile(self, 'zpt/AddECHO_root.zpt')
 3155:         return pt()
 3156: 
 3157: class ECHO_copyrightType(Folder,ECHO_basis):
 3158: 	"""copyright typ"""
 3159: 
 3160: 	meta_type="ECHO_copyrightType"
 3161: 	
 3162: 	def __init__(self,id,title,label,url):
 3163: 		"""init"""
 3164: 		self.id=id
 3165: 		self.title=title
 3166: 		self.label=label
 3167: 		self.url=url
 3168: 
 3169: 	manage_options = Folder.manage_options+(
 3170:         {'label':'Main Config','action':'ECHO_copyrightType_config_mainForm'},
 3171: 	)
 3172: 
 3173: 	def ECHO_copyrightType_config_mainForm(self):
 3174: 		"""change form"""
 3175: 		pt=zptFile(self, 'zpt/ChangeECHO_copyrightType')
 3176: 		pt.content_type="text/html"
 3177: 		return pt()
 3178: 
 3179: 	def ECHO_copyrightType_config_main(self,title,label,url,RESPONSE=None):
 3180: 		"""change"""
 3181: 		self.title=title
 3182: 		self.label=label
 3183: 		self.url=url
 3184: 
 3185: 		if RESPONSE is not None:
 3186: 			RESPONSE.redirect('manage_main')
 3187: 
 3188: def manage_addECHO_copyrightTypeForm(self):
 3189:         """Form for adding a ressource"""
 3190:         pt=zptFile(self, 'zpt/AddECHO_copyrightTypeForm.zpt')
 3191:         return pt()
 3192: 
 3193: 
 3194: def manage_addECHO_copyrightType(self,id,title,label,url,RESPONSE=None):
 3195:     """addaresource"""
 3196: 
 3197:     newObj=ECHO_copyrightType(id,title,label,url)
 3198: 
 3199:     self._setObject(id,newObj)
 3200: 
 3201:     if RESPONSE is not None:
 3202:         RESPONSE.redirect('manage_main')
 3203:  
 3204: 
 3205:  
 3206: class ECHO_partner(Image,Persistent,ECHO_basis):
 3207:     """ECHO Partner"""
 3208: 
 3209:     meta_type="ECHO_partner"
 3210: 
 3211:     def __init__(self, id, title,url, file, copyrightType, person, email, country, color, content_type='', precondition=''):
 3212:         self.__name__=id
 3213:         self.title=title
 3214:         self.url=url
 3215:         self.person=person
 3216:         self.email=email
 3217:         self.country=country
 3218:         self.color=color
 3219:         self.precondition=precondition
 3220:         self.copyrightType=copyrightType
 3221:         data, size = self._read_data(file)
 3222:         content_type=self._get_content_type(file, data, id, content_type)
 3223:         self.update_data(data, content_type, size)
 3224: 
 3225:     manage_options = Image.manage_options+(
 3226:         {'label':'Partner Information','action':'ECHO_partner_config'},
 3227:         )
 3228: 
 3229:     
 3230:     def changeECHO_partner(self,url,copyrightType,person, email, country, color, RESPONSE=None):
 3231:         """Change main information"""
 3232:         self.url=url
 3233:         self.person=person
 3234:         self.email=email
 3235:         self.country=country
 3236:         self.color=color
 3237:         self.copyrightType=copyrightType
 3238:         if RESPONSE is not None:
 3239:             RESPONSE.redirect('manage_main')
 3240:             
 3241:             
 3242: 
 3243:     def ECHO_partner_config(self):
 3244:         """Main configuration"""
 3245:         if not hasattr(self,'url'):
 3246:             self.url=""
 3247:         pt=zptFile(self, 'zpt/ChangeECHO_partner.zpt')
 3248:         return pt()
 3249: 
 3250:         
 3251: manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
 3252:                              Kind='ECHO_partner',kind='ECHO_partner')
 3253: 
 3254: 
 3255: 
 3256: def manage_addECHO_partner(self, id, url, person, email, country, color, file=None, copyrightType='', title='', precondition='', content_type='',
 3257:                     REQUEST=None):
 3258:     """
 3259:     Add a new ECHO_partner object.
 3260: 
 3261:     Creates a new ECHO_partner object 'id' with the contents of 'file'.
 3262:     Based on Image.manage_addImage
 3263:     """
 3264: 
 3265:     id=str(id)
 3266:     title=str(title)
 3267:     content_type=str(content_type)
 3268:     precondition=str(precondition)
 3269: 
 3270:     id, title = OFS.Image.cookId(id, title, file)
 3271: 
 3272:     self=self.this()
 3273: 
 3274:     # First, we create the image without data:
 3275:     self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, color, content_type, precondition))
 3276: 
 3277:     # Now we "upload" the data.  By doing this in two steps, we
 3278:     # can use a database trick to make the upload more efficient.
 3279:     if file:
 3280:         self._getOb(id).manage_upload(file)
 3281:     if content_type:
 3282:         self._getOb(id).content_type=content_type
 3283: 
 3284:     if REQUEST is not None:
 3285:         try:    url=self.DestinationURL()
 3286:         except: url=REQUEST['URL1']
 3287:         REQUEST.RESPONSE.redirect('%s/manage_main' % url)
 3288:     return id
 3289: 
 3290: class ECHO_linkList(ZopePageTemplate,ECHO_basis):
 3291:     """LinkList Objekt"""
 3292:     meta_type="ECHO_linkList"
 3293: 
 3294:     _default_content_fn = os.path.join(package_home(globals()), 'html/ECHO_pageTemplateDefault.html')
 3295: 
 3296:     manage_options = ZopePageTemplate.manage_options+(
 3297:         {'label':'Main Config','action':'changeECHO_linkListWeightForm'},
 3298:         )
 3299: 
 3300:     def content_html(self):
 3301: 	"""content_html"""
 3302: 	return ECHO_basis.content_html(self,'pageTemplate')
 3303: 
 3304:     def changeECHO_linkListWeightForm(self):
 3305:         """change"""
 3306:         pt=zptFile(self, 'zpt/ChangeECHO_linkListTemplate.zpt')
 3307:         return pt()
 3308: 
 3309:     def changeECHO_linkListWeight(self,contentType,label,RESPONSE=None):
 3310:         """change"""
 3311:         self.contentType=contentType
 3312:         self.label=label
 3313:         
 3314:         if RESPONSE is not None:
 3315:             RESPONSE.redirect('manage_main')
 3316: 
 3317:     def getLabel(self):
 3318:         if hasattr(self,'label'):
 3319:             return self.label.encode('utf-8')
 3320:         else:
 3321:             return 0
 3322:         
 3323:     def getcontentType(self):
 3324:         """get contentType"""
 3325:         if hasattr(self,'contentType'):
 3326:             return self.contentType
 3327:         else:
 3328:             return 0
 3329: 
 3330:     def __init__(self, id, label, title=None, text=None, contentType=None):
 3331:          self.id = str(id)
 3332:          self.title=title
 3333:          self.label=label
 3334:          self.ZBindings_edit(self._default_bindings)
 3335:          if text is None:
 3336:              text = ''
 3337:          self.pt_edit(text, contentType)
 3338: 
 3339: 
 3340: 
 3341: 
 3342: def manage_addECHO_linkListForm(self):
 3343:     """Form for adding"""
 3344:     pt=zptFile(self, 'zpt/AddECHO_linkListTemplate.zpt')
 3345:     return pt()
 3346: 
 3347: 
 3348: def manage_addECHO_linkList(self, id, label,contentType=0,title=None, text=None,
 3349:                            REQUEST=None, submit=None):
 3350:     """Add a LinkList with optional file content."""
 3351:     
 3352:     id = str(id)
 3353:     if REQUEST is None:
 3354:         self._setObject(id, ECHO_linkList(id, label, text))
 3355:         ob = getattr(self, id)
 3356:         setattr(ob,'contentType',contentType)
 3357:         if title:
 3358:             ob.pt_setTitle(title)
 3359:         return ob
 3360:     else:
 3361:         file = REQUEST.form.get('file')
 3362:         headers = getattr(file, 'headers', None) 
 3363:         if (headers is None) or (not file.filename):
 3364:             zpt = ECHO_linkList(id, file)
 3365:         else:
 3366:             zpt = ECHO_linkList(id, label,'', file, headers.get('contentType'))
 3367: 
 3368:         self._setObject(id, zpt)
 3369:         ob = getattr(self, id)
 3370:         if title:
 3371:             ob.pt_setTitle(title)
 3372:         
 3373:         try:
 3374:             u = self.DestinationURL()
 3375:         except AttributeError:
 3376:             u = REQUEST['URL1']
 3377: 
 3378:         if submit == " Add and Edit ":
 3379:             u = "%s/%s" % (u, urllib.quote(id))
 3380:         REQUEST.RESPONSE.redirect(u+'/manage_main')
 3381:     return ''
 3382:     
 3383: 
 3384: class ECHO_support(Folder,ECHO_basis):
 3385: 	"""gefoerdert durch"""
 3386: 	meta_type="ECHO_support"
 3387: 	
 3388: 	
 3389: 	
 3390: 	def __init__(self,id,institutions=None):
 3391: 		"""init"""
 3392: 		self.id=id
 3393: 		self.title=''
 3394: 		self.institutions=toList(institutions)
 3395: 
 3396: 	def getSupporter(self):
 3397: 		"""return institutions"""
 3398: 		if self.institutions:
 3399: 			return self.institutions
 3400: 		else:
 3401: 			return []
 3402: 	        
 3403: 	manage_options = Folder.manage_options+(
 3404: 		{'label':'Main Config','action':'ECHO_support_configForm'},
 3405: 		)
 3406: 
 3407: 	def ECHO_support_configForm(self):
 3408: 		"""change form"""
 3409: 		pt=zptFile(self, 'zpt/ChangeECHO_support')
 3410: 		pt.content_type="text/html"
 3411: 		return pt()
 3412: 
 3413: 	def ECHO_support_config(self,institutions=None,RESPONSE=None):
 3414: 		"""change"""
 3415: 		self.institutions=toList(institutions)
 3416: 
 3417: 		if RESPONSE is not None:
 3418: 			RESPONSE.redirect('manage_main')
 3419: 
 3420: 		
 3421: def manage_addECHO_supportForm(self):
 3422:     """Form for adding"""
 3423:     pt=zptFile(self, 'zpt/AddECHO_support.zpt')
 3424:     return pt()
 3425: 
 3426: def manage_addECHO_support(self, id,institutions=None,RESPONSE=None):
 3427: 	"""add the copyright"""
 3428: 
 3429: 	meta_type="ECHO_support"
 3430: 	
 3431: 	
 3432: 	self._setObject(id, ECHO_support(id,institutions))
 3433: 
 3434: 	if RESPONSE is not None:
 3435: 		RESPONSE.redirect('manage_main')
 3436: 		
 3437: 
 3438: class ECHO_institution(Image,Persistent,ECHO_basis):
 3439:     """ECHO Institution"""
 3440: 
 3441:     meta_type="ECHO_institution"
 3442: 
 3443:     def __init__(self, id, title,url, file, person, email, country, content_type='', precondition=''):
 3444:         self.__name__=id
 3445:         self.title=title
 3446:         self.url=url
 3447:         self.person=person
 3448:         self.email=email
 3449:         self.country=country
 3450:         self.precondition=precondition
 3451:         data, size = self._read_data(file)
 3452:         content_type=self._get_content_type(file, data, id, content_type)
 3453:         self.update_data(data, content_type, size)
 3454: 
 3455:     manage_options = Image.manage_options+(
 3456:         {'label':'Institution Information','action':'ECHO_institution_config'},
 3457:         )
 3458: 
 3459:     
 3460:     def changeECHO_institution(self,url,person, email, country,RESPONSE=None):
 3461:         """Change main information"""
 3462:         self.url=url
 3463:         self.person=person
 3464:         self.email=email
 3465:         self.country=country
 3466:         if RESPONSE is not None:
 3467:             RESPONSE.redirect('manage_main')
 3468:             
 3469:             
 3470: 
 3471:     def ECHO_institution_config(self):
 3472:         """Main configuration"""
 3473:         if not hasattr(self,'url'):
 3474:             self.url=""
 3475:         pt=zptFile(self, 'zpt/ChangeECHO_institution.zpt')
 3476:         return pt()
 3477: 
 3478:         
 3479: manage_addECHO_institutionForm=DTMLFile('dtml/ECHO_institutionAdd',globals(),
 3480:                              Kind='ECHO_institution',kind='ECHO_institution')
 3481: 
 3482: 
 3483: 
 3484: def manage_addECHO_institution(self, id, url, person, email, country, file=None, title='', precondition='', content_type='',
 3485:                     REQUEST=None):
 3486:     """
 3487:     Add a new ECHO_institution object.
 3488: 
 3489:     Creates a new ECHO_institution object 'id' with the contents of 'file'.
 3490:     Based on Image.manage_addImage
 3491:     """
 3492: 
 3493:     id=str(id)
 3494:     title=str(title)
 3495:     content_type=str(content_type)
 3496:     precondition=str(precondition)
 3497: 
 3498:     id, title = OFS.Image.cookId(id, title, file)
 3499: 
 3500:     self=self.this()
 3501: 
 3502:     # First, we create the image without data:
 3503:     self._setObject(id, ECHO_institution(id,title,url,'', person, email, country, content_type, precondition))
 3504: 
 3505:     # Now we "upload" the data.  By doing this in two steps, we
 3506:     # can use a database trick to make the upload more efficient.
 3507:     if file:
 3508:         self._getOb(id).manage_upload(file)
 3509:     if content_type:
 3510:         self._getOb(id).content_type=content_type
 3511: 
 3512:     if REQUEST is not None:
 3513:         try:    url=self.DestinationURL()
 3514:         except: url=REQUEST['URL1']
 3515:         REQUEST.RESPONSE.redirect('%s/manage_main' % url)
 3516:     return id
 3517: 
 3518: def repairCoords(self):
 3519: 	"""updates map coordinates to new MapArea objects"""
 3520: 	msg = ""
 3521: 	for cols in self.ZopeFind(self, obj_metatypes=['ECHO_collection','ECHO_resource'], search_sub=1):
 3522: 	    col = cols[1]
 3523: 	    if not hasattr(col, 'coords'):
 3524: 		continue
 3525: 	    print "fixing: ", col.id
 3526: 	    msg += "fixing: "+col.id+"\n"
 3527: 	    coords = col.coords
 3528: 	    if len(coords) > 0:
 3529: 		# delete old MapAreas
 3530: 		for areas in self.ZopeFind(col, obj_metatypes=['MapArea']):
 3531: 		    #area = areas[1]
 3532: 		    id = areas[0]
 3533: 		    print "  deleting: ", id
 3534: 		    msg += "  deleting: "+id+"\n"
 3535: 		    col._delObject(id)
 3536: 		# add new MapAreas
 3537: 		areacnt = 0
 3538: 		for coord in coords:
 3539: 		    if len(coord) < 4:
 3540: 			continue
 3541: 		    type = col.viewClassification
 3542: 		    if type == 'view point':
 3543: 			type = 'arrow'
 3544: 		    if type is None:
 3545: 			if len(coord) > 4:
 3546: 			    type = 'arrow'
 3547: 			else:
 3548: 			    type = 'area'
 3549: 		    newid = "a%02d"%areacnt
 3550: 		    areacnt += 1
 3551: 		    area = MapArea(newid, coord, type=type)
 3552: 		    print  "  adding: ", newid
 3553: 		    msg += "  adding: "+newid+"\n"
 3554: 		    col.addMapArea(area)
 3555: 	msg += "\nDone!"
 3556: 	return msg

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