Return to ECHO_collection.py CVS log

Up to [Repository] / ECHO_content

cnages vlp_coll to references

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