Return to ECHO_collection.py CVS log

Up to [Repository] / ECHO_content

transfered methods from ECHO_collection.py to ECHO_helpers.py

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