File:  [Repository] / ECHO_content / ECHO_collection.py
Revision 1.143: download - view: text, annotated - select for diffs - revision graph
Sun Jul 18 14:38:11 2004 UTC (19 years, 10 months ago) by dwinter
Branches: MAIN
CVS tags: HEAD
rdf changes

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

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