Return to ECHO_collection.py CVS log

Up to [Repository] / ECHO_content

:x

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