Return to ECHO_collection.py CVS log

Up to [Repository] / ECHO_content

fixed tag names in getMetaDatasXML

    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:     
 1715:     def getImageTag(self):
 1716:         """GetTag"""
 1717:         try:
 1718:             return self.imageTag
 1719:         except:
 1720:             return ""
 1721: 
 1722:     def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
 1723:         """SSS"""
 1724:         try:
 1725:             manage_addECHO_resource(self,id,title,label,description,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
 1726:             return "done"
 1727:         except:
 1728:             return None
 1729: 
 1730:     def getSecondaryLink(self):
 1731:         """secondary link"""
 1732:         try:
 1733:             return self.secondaryLink
 1734:         except:
 1735:             return ""
 1736: 
 1737:     def getSecondaryLinkTitle(self):
 1738:         """secondary link"""
 1739:         try:
 1740:             return self.secondaryLinkTitle
 1741:         except:
 1742:             return ""
 1743:         
 1744:     def getCollectionTreeXML(self):
 1745:         """Tree as XML"""
 1746: 
 1747:         def getCollection(object,depth=0):
 1748:             depth+=1
 1749:             collections=""
 1750:             for entry in object.__dict__.keys():
 1751:                 element=getattr(object,entry)
 1752:                 try:
 1753:                     if element.meta_type in ["ECHO_collection","ECHO_group"]:
 1754:                         collections+="<element name=\""+quote(element.title)+"\" url=\""+element.absolute_url()+"\">"
 1755:                         collections+=getCollection(element,depth)+"</element>\n"
 1756:                 except:
 1757:                     """nothing"""
 1758:             return collections
 1759:         
 1760: 	ret="""<?xml version="1.0" encoding="utf-8" ?>"""
 1761:         return ret+"<collection>"+getCollection(self)+"</collection>"
 1762:     
 1763:     def createJavaScript(self):
 1764:         """OLD CreateJava"""
 1765:         ret=javaScriptMain
 1766: 
 1767:         dynamical="\n"
 1768:         for ob in self.getGraphicCoords():
 1769: 	    if ob[4][4] == "":	
 1770: 	        dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])
 1771: 	    else:
 1772: 		dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])
 1773: 		dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])
 1774: 	ret+=javaHandler%dynamical
 1775:         return ret
 1776: 
 1777:     def createJSAreas(self):
 1778:         """create area calls for JavaScript"""
 1779:         dynamical="\n"
 1780:         for ob in self.getGraphicCoords():
 1781: 	    if ob[5] == "area":
 1782: 	        dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob[1],ob[0])
 1783: 	    else:
 1784: 	        dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob[1],ob[0])
 1785:         return dynamical
 1786: 
 1787:     def createMapHead(self):
 1788:         """create javascript include and script tags for head"""
 1789:         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)
 1790:         return pt()
 1791: 
 1792:     def createMapImg(self):
 1793: 	"""generate img-tag for map"""
 1794: 	bt = BrowserCheck(self)
 1795: 	tag = ""
 1796: 	src = self.REQUEST['URL1'] + "/overview"
 1797: 	if bt.isN4:
 1798: 	    tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src
 1799: 	else:
 1800: 	    tag += '<img id="overview" src="%s" />'%src
 1801: 	return tag
 1802:         
 1803:     def createMapLink(self, ob, text=None):
 1804: 	"""generate map link"""
 1805: 	bt = BrowserCheck(self)
 1806: 	id = ob[1]
 1807: 	link = ob[1]
 1808: 	if text == None:
 1809: 	    text = ob[2]
 1810: 	tag = ""
 1811: 	if bt.isN4:
 1812: 	    tag += '<ilayer id="a.%s"><a onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
 1813: 	    tag += ">" + text + "</a></ilayer>"
 1814: 	else:
 1815: 	    tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
 1816: 	    if ob[3].contentType == 'text-popup':
 1817: 		tag += ' title="%s"'%ob[3].description
 1818: 	    tag += ">" + text + "</a>"
 1819: 	return tag
 1820: 
 1821:     def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil"):
 1822: 	"""generate map link image, text and other stuff"""
 1823: 	id = ob[1]
 1824: 	link = ob[1]
 1825: 	vtype = ob[5]
 1826: 	ctype = ob[3].contentType
 1827: 	bt = BrowserCheck(self)
 1828: 	tag = ""
 1829: 
 1830: 	if bt.isN4:
 1831: 	    tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)
 1832: 	    if vtype == "view point":
 1833: 	        rot = ob[4][4]
 1834: 		tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,arrowsrc,rot)
 1835: 	    else:
 1836: 		tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)
 1837: 		if ctype == "text-popup":
 1838: 		    desc = ob[3].description
 1839: 		    tag += ' alt="%s"'%desc
 1840: 		tag += ' /></a>'
 1841: 	    tag += '</layer>'
 1842: 	else:
 1843: 	    tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)
 1844: 	    if vtype == "view point":
 1845: 		rot = ob[4][4]
 1846: 		if bt.isIEWin and bt.versIE > 5:
 1847: 		    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)
 1848: 		else:
 1849: 		    tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,arrowsrc,rot)
 1850: 	    else:
 1851: 		if bt.isIEWin:
 1852: 		    tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;background:url(area_img)"'%(id)
 1853: 		else:
 1854: 		    tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
 1855: 		if ctype == "text-popup":
 1856: 		    desc = ob[3].description
 1857: 		    tag += ' title="%s"'%desc
 1858: 		tag += '> </div>'
 1859: 	    tag += '</a>'
 1860: 	return tag
 1861: 
 1862:     
 1863:     security.declarePublic('getCreditObject')
 1864:     def getCreditObject(self,name):
 1865:         """credit id to credititem"""
 1866:         try:
 1867:             return getattr(self.partners,name)
 1868:         except:
 1869:             return ""
 1870: 
 1871:     security.declarePublic('ECHO_generateNavBar')
 1872:     def ECHO_generateNavBar(self):
 1873:         """Erzeuge Navigationsbar"""
 1874:         link=""
 1875:         object="self"
 1876:         ret=[]
 1877:         path=self.getPhysicalPath()
 1878:         for element in path:
 1879:             
 1880:            
 1881:             if not element=="":
 1882:                 object+="."+element
 1883:                 
 1884:                 label=eval(object).label
 1885:                 link+="/"+element
 1886:                 if not label=="":
 1887:                     ret.append((label,link))
 1888:         return ret
 1889:     
 1890:     security.declarePublic('ECHO_rerenderLinksMD')
 1891: 
 1892:     def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
 1893:         """Rerender all Links"""
 1894: 	ret=""
 1895: 	
 1896:         if not obj:
 1897:             obj = self
 1898:             
 1899:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
 1900: 
 1901:         for entry in entries:
 1902: 		if entry[1].meta_type == 'ECHO_resource':
 1903: 			try:
 1904: 				entry[1].ECHO_getResourceMD(template="no")
 1905:                                 if "title" in types:
 1906:                                     entry[1].generate_title()
 1907:                                 if "label" in types:
 1908:                                     entry[1].generate_label()
 1909: 				ret+="OK:"+entry[0]+"-- "+entry[1].getTitle().decode('utf-8')+"-- "+entry[1].getTitle().decode('utf-8')+"<br>"
 1910: 			except:
 1911: 				ret+="Error:"+entry[0]+"<br>"
 1912: 
 1913: 		else:
 1914: 		   self.ECHO_rerenderLinksMD(entry[1])
 1915: 
 1916:                 
 1917:                 
 1918:         return ret+"Rerenderd all links to resources in: "+self.title
 1919: 
 1920:     security.declarePublic('ECHO_newViewerLink')
 1921:     
 1922: 
 1923:     def getCoords(self):
 1924:         try:
 1925:             
 1926:             x=  [string.join(x,",") for x in self.coords]  
 1927:             return x
 1928: 
 1929:         except:
 1930: 
 1931:             return []
 1932:         
 1933:     def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):
 1934: 
 1935: 
 1936:         self.id = id
 1937:         """Festlegen der ID"""
 1938:         self.credits=toList(credits)
 1939:         self.label = label
 1940:         self.title=title
 1941:         self.description=description
 1942:         self.contentType=contentType
 1943:         self.responsible=responsible
 1944:         self.imageTag=imageTag
 1945:         self.weight=weight
 1946:         self.sortfield=sortfield
 1947:         coordsnew=[ string.split(x,",") for x in coords]
 1948:         self.coords=coordsnew
 1949:         self.secondaryLinkTitle=secondaryLinkTitle
 1950:         self.secondaryLink=secondaryLink
 1951: 	self.bgcolour=bgcolour
 1952:         
 1953: 
 1954:     manage_options = Folder.manage_options+(
 1955:         {'label':'Main Config','action':'ECHO_collection_config'},
 1956:         {'label':'Change Labels','action':'changeLabels'},
 1957:         {'label':'Change Titles','action':'changeTitles'},
 1958:         {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMD'},
 1959:         {'label':'Graphics','action':'ECHO_graphicEntry'},
 1960: 	{'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
 1961:         {'label':'Change Viewer Templates','action':'changeViewerTemplateSetsForm'},
 1962: 	{'label':'Reload Metadata','action':'reloadMetaDataFromStorage'},
 1963: 	{'label':'ImportCollection','action':'updateCollection'},
 1964: 	{'label':'Copy MD for indexing and search','action':'copySearchFields'},
 1965:         )
 1966: 
 1967:     def getOverview(self):
 1968:         """overview graphics"""
 1969:         
 1970:         return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
 1971:     
 1972:     
 1973:     def ECHO_graphicEntry(self):
 1974:         """DO nothing"""
 1975:         overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
 1976:         
 1977:     
 1978:         if overview:
 1979:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
 1980:             return pt()
 1981:         else:
 1982:             return "NO OVERVIEW GRAPHICS"
 1983: 
 1984:     def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
 1985:         """Enter coords"""
 1986:         coords=self.coords
 1987:         temco=coordstr.split(",")
 1988:         temco.append(angle)
 1989:         coords.append(temco)
 1990:         self.coords=coords[0:]
 1991: 
 1992:         if RESPONSE is not None:
 1993:             RESPONSE.redirect('ECHO_graphicEntry')
 1994: 
 1995:     
 1996:     security.declarePublic('ECHO_collection_config')
 1997:     def ECHO_collection_config(self):
 1998:         """Main configuration"""
 1999: 
 2000:         if not hasattr(self,'weight'):
 2001:             self.weight=""
 2002: 
 2003:         if not hasattr(self,'sortfield'):
 2004:             self.sortfield="weight"
 2005:   
 2006:         if not hasattr(self,'coords'):
 2007:             self.coords=[]
 2008: 
 2009:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_collection.zpt').__of__(self)
 2010:         return pt()
 2011: 
 2012: 
 2013:     security.declarePublic('changeECHO_collection')
 2014: 
 2015: 
 2016:     def getBgcolour(self):
 2017: 	    """colour"""
 2018: 	    if hasattr(self,'bgcolour') and not (self.bgcolour==""):
 2019: 		    return self.bgcolour
 2020: 	    else:
 2021: 		    return "#dddddd"
 2022: 	    
 2023:     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):
 2024:         """Aenderung der Properties"""
 2025: 
 2026:         self.secondaryLink=secondaryLink
 2027:         self.secondaryLinkTitle=secondaryLinkTitle
 2028:         self.imageTag=imageTag
 2029: 	self.bgcolour=bgcolour
 2030:         self.viewClassification=viewClassification
 2031:         self.location=location
 2032: 	
 2033:         if coords:
 2034:             coordsnew=[ string.split(x,",") for x in coords]
 2035:             self.coords=coordsnew[0:]
 2036:         else:
 2037:             coordsnew=None
 2038:             self.coords=None
 2039:             
 2040:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
 2041: 	try:
 2042: 		self.coords=coordsnew[0:] # HACK fehler in setECHO_collection
 2043:         except:
 2044: 		"""none"""
 2045: 		
 2046:         self.sortfield=sortfield
 2047: 
 2048:         if RESPONSE is not None:
 2049:             RESPONSE.redirect('manage_main')
 2050:             
 2051: 
 2052:     def showOverview(self):
 2053:         """overview"""
 2054:         if 'ECHO_overview.html' in self.__dict__.keys():
 2055:             return getattr(self,'ECHO_overview.html')()
 2056:         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)
 2057:         return pt()
 2058: 
 2059:     security.declareProtected('View','index_html')
 2060:     
 2061:     def index_html(self):
 2062:         """standard page"""
 2063:         
 2064:         if 'index.html' in self.__dict__.keys():
 2065:             return getattr(self,'index.html')()
 2066:         
 2067:         elif 'overview' in self.__dict__.keys():
 2068:             return self.showOverview()
 2069:         elif hasattr(self,'collection_index_template'):
 2070:             return self.collection_index_template()    
 2071:         elif hasattr(self,'main_index_template'):
 2072:             return self.main_index_template()    
 2073:         
 2074:         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
 2075:         pt.content_type="text/html"
 2076:         return pt()
 2077: 
 2078:     def content_html(self):
 2079:         """template fuer content"""
 2080:         return content_html(self,'collection')
 2081:     
 2082:     def getCredits(self):
 2083:         """Ausgabe der credits"""
 2084:         if self.credits:
 2085:             return self.credits
 2086:         else:
 2087:             return []
 2088: 
 2089:     def area_img(self):
 2090:         """area image"""
 2091: 	bt = BrowserCheck(self)
 2092: 	if bt.isIE or bt.isN4:
 2093: 	    return sendFile(self, 'images/red.gif', 'image/gif')
 2094: 	else:
 2095: 	    return sendFile(self, 'images/reda.png', 'image/png')
 2096: 
 2097:     def trans_img(self):
 2098:         """empty image"""
 2099:         return sendFile(self, 'images/trans.gif', 'image/gif')
 2100: 
 2101:     def hl_lib_js(self):
 2102:         """javascript"""
 2103:         return sendFile(self, 'js/hl_lib.js', 'text/plain')
 2104: 
 2105:     def js_lib_js(self):
 2106:         """javascript"""
 2107:         return sendFile(self, 'js/js_lib.js', 'text/plain')
 2108: 
 2109:     def getGraphicCoords(self):
 2110:         """Give list of coordinates"""
 2111:         subColTypes=['ECHO_collection','ECHO_resource']
 2112:         ids=[]
 2113:         for entrySearch in self.ZopeFind(self,obj_metatypes=subColTypes):
 2114:             object=entrySearch[1]
 2115:             if hasattr(object,'coords'):
 2116:                 for coordtemp in object.coords:
 2117:                     if len(coordtemp)>3:
 2118:                         coord=coordtemp[0:4]
 2119:                         label=""
 2120: 			vc=""
 2121:                         if hasattr(object,'label') and not object.label=="":
 2122:                             label=object.label
 2123:                         elif hasattr(object,'title') and not object.title=="":
 2124:                             label=object.title
 2125:                         else:
 2126:                             label=object.getId()
 2127: 			if object.viewClassification != "":
 2128: 			    vc=object.viewClassification
 2129: 			else:
 2130: 			    if len(coordtemp) > 4 and coordtemp[4] != "":
 2131: 				vc="view point"
 2132: 			    else:
 2133: 				vc="area"
 2134:                         ids.append([string.join(coord,", "),object.getId(),label,object,coordtemp,vc])
 2135:         return ids
 2136:     
 2137: 
 2138: 
 2139: 
 2140:     getSubCols = ECHO_helpers.getSubCols
 2141: 
 2142: Globals.InitializeClass(ECHO_collection)
 2143:     
 2144: def manage_addECHO_collectionForm(self):
 2145:         """Add collection form"""
 2146:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)
 2147:         return pt()
 2148: 
 2149: 
 2150: def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
 2151:     """add a echo collection"""
 2152:     
 2153: 
 2154:     newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
 2155: 
 2156:     self._setObject(id,newObj)
 2157: 
 2158:     if RESPONSE is not None:
 2159:         RESPONSE.redirect('manage_main')
 2160: 
 2161: class ECHO_group(ECHO_collection):
 2162: 	"""ECHO Gruppe"""
 2163: 	security=ClassSecurityInfo()
 2164: 	meta_type="ECHO_group"
 2165: 
 2166: 	manage_options = Folder.manage_options+(
 2167: 		{'label':'Main Config','action':'ECHO_group_config'},
 2168: 		{'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
 2169: 		{'label':'Graphics','action':'ECHO_graphicEntry'},
 2170: 		)
 2171: 	
 2172: 	security.declareProtected('View','index_html')
 2173: 	def index_html(self):
 2174: 		"""standard page"""
 2175: 		displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
 2176: 		#if (len(displayedObjects)==1) and (displayedObjects[0][1].meta_type=="ECHO_collection"): # nur ein Object dann redirect auf dieses Object
 2177: 		#	return self.REQUEST.RESPONSE.redirect(displayedObjects[0][1].absolute_url())
 2178: 		
 2179: 		if 'index.html' in self.__dict__.keys():
 2180: 			return getattr(self,'index.html')()
 2181: 		
 2182: 		elif 'overview' in self.__dict__.keys():
 2183: 			return self.showOverview()
 2184: 		elif hasattr(self,'group_index_template'):
 2185: 			return self.group_index_template()
 2186: 		elif hasattr(self,'collection_index_template'):
 2187: 			return self.collection_index_template()    
 2188: 		elif hasattr(self,'main_index_template'):
 2189: 		    return self.main_index_template()    
 2190: 
 2191: 		pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
 2192: 		pt.content_type="text/html"
 2193: 		return pt()
 2194: 
 2195: 	def ECHO_group_config(self):
 2196: 		"""Main configuration"""
 2197: 		
 2198: 		if not hasattr(self,'weight'):
 2199: 			self.weight=""
 2200: 			
 2201: 		if not hasattr(self,'sortfield'):
 2202: 			self.sortfield="weight"
 2203: 				
 2204: 		if not hasattr(self,'coords'):
 2205: 			self.coords=[]
 2206: 
 2207: 		pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)
 2208: 		return pt()
 2209: 
 2210: 	def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
 2211: 		"""Änderung der Properties"""
 2212: 
 2213: 		self.secondaryLink=secondaryLink
 2214: 		self.secondaryLinkTitle=secondaryLinkTitle
 2215: 		self.imageTag=imageTag
 2216: 		self.bgcolour=bgcolour
 2217:                 self.logo=logo
 2218:                 
 2219: 		if coords:
 2220: 		    coordsnew=[ string.split(x,",") for x in coords]
 2221: 		    self.coords=coordsnew[0:]
 2222: 		else:
 2223: 		    coordsnew=None
 2224: 		    self.coords=None
 2225: 
 2226: 		setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
 2227: 
 2228: 
 2229: 
 2230: 		self.sortfield=sortfield
 2231: 
 2232: 		if RESPONSE is not None:
 2233: 		    RESPONSE.redirect('manage_main')
 2234: 
 2235: 	def getLogo(self):    
 2236: 		"""logo ausgeben"""
 2237:                 try:
 2238:                     return self.logo
 2239:                 except:
 2240:                     return "ECHO_groups"
 2241: 
 2242: 	def content_html(self):
 2243: 		"""template fuer content"""
 2244: 		return content_html(self,'group')
 2245:     
 2246: 
 2247: 
 2248: def manage_addECHO_groupForm(self):
 2249:         """Add group form"""
 2250:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)
 2251:         return pt()
 2252: 
 2253: 
 2254: def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
 2255:     """add a echo group"""
 2256:     
 2257: 
 2258:     newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
 2259: 
 2260:     setattr(newObj,'logo',logo)
 2261:     self._setObject(id,newObj)
 2262:     
 2263:     if RESPONSE is not None:
 2264:         RESPONSE.redirect('manage_main')
 2265: 
 2266: Globals.InitializeClass(ECHO_group)
 2267: 
 2268: 
 2269: class ECHO_userFolder(UserFolder):
 2270: 	"""User folder for Intranet"""
 2271: 	_domain_auth_mode=1 # Identification via domain
 2272: 	meta_type="ECHO_userFolder"
 2273: 	
 2274: 	def authenticate(self, name, password, request):
 2275: 		emergency = self._emergency_user
 2276: 		if name is None:
 2277: 		    return None
 2278: 		if emergency and name==emergency.getUserName():
 2279: 		    user = emergency
 2280: 		else:
 2281: 		    user = self.getUser(name)
 2282: 		if user is not None and user.authenticate(password, request):
 2283: 		    return user
 2284: 		else:
 2285: 		    return None
 2286: 
 2287: 	def domainSpecMatch(self,spec, request):
 2288: 	    host=''
 2289: 	    addr=''
 2290: 
 2291: 	    # Fast exit for the match-all case
 2292: 	    if len(spec) == 1 and spec[0] == '*':
 2293: 		return 1
 2294: 
 2295: 	    if request.has_key('REMOTE_HOST'):
 2296: 		host=request['REMOTE_HOST']
 2297: 
 2298: 	    if request.has_key('REMOTE_ADDR'):
 2299: 		addr=request['REMOTE_ADDR']
 2300: 
 2301: 	    if request.has_key('HTTP_X_FORWARDED_FOR'):
 2302: 		addr=request['HTTP_X_FORWARDED_FOR']
 2303: 
 2304: 	    
 2305: 	    if not host and not addr:
 2306: 		return 0
 2307: 
 2308: 	    if not host:
 2309: 		try:    host=socket.gethostbyaddr(addr)[0]
 2310: 		except: pass
 2311: 	    if not addr:
 2312: 		try:    addr=socket.gethostbyname(host)
 2313: 		except: pass
 2314: 
 2315: 
 2316: 	    _host=host.split('.')
 2317: 	    _addr=addr.split('.')
 2318: 	    _hlen=len(_host)
 2319: 	    _alen=len(_addr)
 2320: 
 2321: 	    for ob in spec:
 2322: 		sz=len(ob)
 2323: 		_ob=ob.split('.')
 2324: 		_sz=len(_ob)
 2325: 
 2326: 		mo = addr_match(ob)
 2327: 		if mo is not None:
 2328: 		    if mo.end(0)==sz:
 2329: 			fail=0
 2330: 			for i in range(_sz):
 2331: 			    a=_addr[i]
 2332: 			    o=_ob[i]
 2333: 			    if (o != a) and (o != '*'):
 2334: 				fail=1
 2335: 				break
 2336: 			if fail:
 2337: 			    continue
 2338: 			return 1
 2339: 
 2340: 		mo = host_match(ob)
 2341: 		if mo is not None:
 2342: 		    if mo.end(0)==sz:
 2343: 			if _hlen < _sz:
 2344: 			    continue
 2345: 			elif _hlen > _sz:
 2346: 			    _item=_host[-_sz:]
 2347: 			else:
 2348: 			    _item=_host
 2349: 			fail=0
 2350: 			for i in range(_sz):
 2351: 			    h=_item[i]
 2352: 			    o=_ob[i]
 2353: 			    if (o != h) and (o != '*'):
 2354: 				fail=1
 2355: 				break
 2356: 			if fail:
 2357: 			    continue
 2358: 			return 1
 2359: 	    return 0
 2360: 
 2361: Globals.default__class_init__(ECHO_userFolder)
 2362: 
 2363: 
 2364: 
 2365: def manage_addECHO_userFolder(self,dtself=None,REQUEST=None,**ignored):
 2366:     """add a user folder """
 2367:     f=ECHO_userFolder()
 2368:     self=self.this()
 2369:     try:    self._setObject('acl_users', f)
 2370:     except: return MessageDialog(
 2371:                    title  ='Item Exists',
 2372:                    message='This object already contains a User Folder',
 2373:                    action ='%s/manage_main' % REQUEST['URL1'])
 2374:     self.__allow_groups__=f
 2375:     if REQUEST is not None:
 2376:         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
 2377: 
 2378: def manage_addECHO_userFolderForm(self):
 2379: 	"""add a user folder form"""
 2380: 	return manage_addECHO_userFolder(self)
 2381: 
 2382: class ECHO_root(Folder,Persistent,Implicit):
 2383:     """ECHO Root Folder"""
 2384: 
 2385:     security=ClassSecurityInfo()
 2386:     
 2387:     meta_type="ECHO_root"
 2388: 
 2389:     def showContent(self,path):
 2390: 	    """return content/html"""
 2391: 	    
 2392: 	    return urllib.urlopen(path+"/content_html").read()
 2393:     
 2394:     def getImageViewers(self):
 2395:         """images"""
 2396:         viewers=self.ZopeFind(self.standardImageViewer,obj_metatypes=['OSAS_ViewerObject'])
 2397:         return viewers
 2398:     
 2399: 
 2400:     def getBibTag(self,tag,content):
 2401: 	    """get field tag für index-meta-generation"""
 2402: 	    if not content or content=="":
 2403: 		    return ""
 2404: 	    ret="<%s>"%tag
 2405: 	    #ret+=urllib.quote(content)
 2406: 	    ret+=content
 2407: 
 2408: 	    ret+="</%s>"%tag
 2409: 	    return ret
 2410: 
 2411:     def getValueFromClass(self,field,found):
 2412: 	    """retattribute falss existing"""
 2413: 	    try:
 2414: 		    
 2415: 		    return getattr(found,field).decode('ascii','ignore')
 2416: 	    except:
 2417: 		    return ""
 2418:     
 2419:     def getImageTag(self):
 2420: 	    """needed by main_template"""
 2421: 	    return ""
 2422:     secondaryLink="" #needed by main_template
 2423:     secondaryLinkTitle="" #needed by main_template
 2424:     
 2425:     def getBgcolour(self):
 2426: 	"""hack"""
 2427: 	return "#dddddd"
 2428: 
 2429:     def contentTypeSelector_HTML(self,selected=None):
 2430:         """give type selector"""
 2431:         if not selected:
 2432:             retStr="<option selected>\n"
 2433:         else:
 2434:             retStr="<option>\n"
 2435:             
 2436:         try: # erste version contentTypes exists
 2437:             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):
 2438:                 if selected and (contentType[0]==selected):
 2439:                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
 2440:                 else:                
 2441:                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
 2442:         except:
 2443: 		try:
 2444: 			for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):
 2445: 				if selected and (contentType[0]==selected):
 2446: 					retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
 2447: 				else:                
 2448: 					retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
 2449: 		except:
 2450: 			"""nothing"""
 2451: 			    
 2452: 	return retStr
 2453: 
 2454:     def renderingTypeSelector_HTML(self,selected=None):
 2455:          """give type selector"""
 2456: 	 if not selected:
 2457: 		 retStr="<option selected>\n"
 2458: 	 else:
 2459: 		 retStr="<option>\n"
 2460: 		 
 2461: 	 try: # erste version renderingTypes exists
 2462: 		 for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
 2463: 			 if selected and (renderingType[0]==selected):
 2464: 				 retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
 2465: 			 else:                
 2466: 				 retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
 2467: 	 except:
 2468: 		 """nothing"""
 2469: 	 return retStr
 2470: 
 2471:     def renderingTypeSelector_HTML(self,selected=None):
 2472:          """give type selector"""
 2473: 	 if not selected:
 2474: 		 retStr="<option selected>\n"
 2475: 	 else:
 2476: 		 retStr="<option>\n"
 2477: 		 
 2478: 	 try: # erste version renderingTypes exists
 2479: 		 for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
 2480: 			 if selected and (renderingType[0]==selected):
 2481: 				 retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
 2482: 			 else:                
 2483: 				 retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
 2484: 	 except:
 2485: 		 """nothing"""
 2486: 	 return retStr
 2487: 
 2488: 
 2489:     def copyrightTypeSelector_HTML(self,selected=None,first=None):
 2490:          """give type selector"""
 2491: 
 2492: 	 if not first:
 2493: 		 if not selected:
 2494: 			 retStr="<option selected>\n"
 2495: 		 else:
 2496: 			 retStr="<option>\n"
 2497: 	 else:
 2498: 		 if not selected:
 2499: 			 retStr="""<option selected value="%s">%s\n"""%first
 2500: 		 else:
 2501: 			 retStr="""<option value="%s">%s\n"""%first
 2502: 
 2503: 	 
 2504: 	 try: # erste version copyrightTypes exists
 2505: 		 for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
 2506: 			 if selected and (copyrightType[0]==selected):
 2507: 				 retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
 2508: 			 else:                
 2509: 				 retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
 2510: 	 except:
 2511: 		 """nothing"""
 2512: 	 return retStr
 2513: 
 2514:     def partnerSelector_HTML(self,selected=None):
 2515:          """give type selector"""
 2516: 	 if not selected:
 2517: 		 retStr="<option selected>\n"
 2518: 	 else:
 2519: 		 retStr="<option>\n"
 2520: 		 
 2521: 	 try: # erste version copyrightTypes exists
 2522: 		 for copyrightType in self.ZopeFind(self.partners,obj_metatypes=["ECHO_partner"]):
 2523: 			 if selected and (copyrightType[0]==selected):
 2524: 				 retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
 2525: 			 else:                
 2526: 				 retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
 2527: 	 except:
 2528: 		 """nothing"""
 2529: 	 return retStr
 2530:  
 2531:     mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version über echoroot??
 2532: 
 2533:     def mediaTypeSelector_HTML(self,selected=None):
 2534:          """give type selector"""
 2535: 	 if not selected:
 2536: 		 retStr="<option selected>\n"
 2537: 	 else:
 2538: 		 retStr="<option>\n"
 2539: 	 
 2540: 	 try: # erste version mediatypesTypes exists
 2541: 		 for mediaType in self.mediaTypes:
 2542: 			 if selected and (mediaType in selected):
 2543: 				 retStr+="""<option selected value="%s">%s\n"""%(mediaType,mediaType)
 2544: 			 else:                
 2545: 				 retStr+="""<option value="%s">%s\n"""%(mediaType,mediaType)
 2546: 	 except:
 2547: 		 """nothing"""
 2548: 	 return retStr
 2549: 
 2550:             
 2551:     def patchContentType(self,obj=None):
 2552:         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
 2553:     
 2554: 
 2555:         if not obj:
 2556:             obj = self
 2557:             
 2558:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
 2559: 
 2560:         for entry in entries:
 2561:                 setattr(entry[1],'contentType',entry[1].content_type)
 2562:                 #entry[1].contentType == entry[1].content_type
 2563: 
 2564:                 if entry[1].meta_type == 'ECHO_collection':
 2565:                     entry[1].patchContentType(entry[1])    
 2566: 
 2567:                 
 2568:         return "changed all contenttypes in: "+self.title
 2569: 
 2570: 
 2571:     def patchViewClassification(self,obj=None):
 2572:         """setze viewClassification heuristisch"""
 2573: 
 2574: 	def checkIfArrow(obj):
 2575: 		if hasattr(obj,'coords'):
 2576: 			for coordtemp in obj.coords:
 2577: 
 2578: 				if (len(coordtemp)>4) and not (coordtemp[4]==''):
 2579: 					return 4
 2580: 			return None
 2581: 		return None
 2582: 	
 2583:         if not obj:
 2584:             obj = self
 2585:             
 2586:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])
 2587: 
 2588:         for entry in entries:
 2589: 		
 2590: 		if checkIfArrow(entry[1]):
 2591: 			setattr(entry[1],'viewClassification','view point')
 2592: 		else:
 2593: 			setattr(entry[1],'viewClassification','area')
 2594: 
 2595:                 #entry[1].contentType == entry[1].content_type
 2596: 
 2597:                 if entry[1].meta_type in ['ECHO_collection','ECHO_group']:
 2598:                     entry[1].patchViewClassification(entry[1])    
 2599: 
 2600:                 
 2601:         return "changed all contenttypes in: "+self.title
 2602: 
 2603:     def ECHO_newViewerLink(self,obj=None):
 2604:         """change links (:86 faellt weg)"""
 2605: 
 2606:         if not obj:
 2607:             obj = self
 2608:             
 2609:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
 2610: 
 2611:         for entry in entries:
 2612:                 
 2613:                 if entry[1].meta_type == 'ECHO_resource':
 2614:                     
 2615:                     entry[1].link=re.sub('\:86','',entry[1].link)
 2616: 
 2617:                 else:
 2618:                     
 2619:                     entry[1].ECHO_newViewerLink(entry[1])
 2620:                 
 2621:         return "Rerenderd all links to resources in: "+self.title
 2622: 
 2623:     def __init__(self,id,title):
 2624:         """init"""
 2625:         self.id = id
 2626:         self.title=title
 2627: 
 2628:     def deleteSpace(self,str):
 2629:         """delete space at the end of a line"""
 2630:         if str[len(str)-1]==" ":
 2631:             return str[0:len(str)-1]
 2632:         else:
 2633:             return str
 2634:         
 2635:     
 2636: 
 2637:     # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
 2638: 
 2639:     def formatAscii(self,str,url=None):
 2640:         """ersetze ascii umbrueche durch <br>"""
 2641:         #url=None
 2642:         if url:
 2643:             
 2644:             retStr=""
 2645:             words=str.split("\n")
 2646:             
 2647:             for word in words:
 2648:                 strUrl=url%word
 2649: 
 2650:                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
 2651:             str=retStr
 2652:         if str:
 2653:             return re.sub(r"[\n]","<br/>",str)
 2654:         else:
 2655:             return ""
 2656:         
 2657:     def link2html(self,str):
 2658:         """link2html fuer VLP muss hier noch raus"""
 2659:         if str:
 2660: 
 2661:             str=re.sub("\&","&amp;",str)
 2662:             dom=xml.dom.minidom.parseString("<?xml version='1.0' encoding='utf-8'?><txt>"+str+"</txt>")
 2663:             links=dom.getElementsByTagName("link")
 2664:             
 2665: 
 2666:             for link in links:
 2667:                 link.tagName="a"
 2668:                 ref=link.getAttribute("ref")
 2669:                 if self.checkRef(ref):
 2670:                     link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
 2671: 
 2672:             newxml=dom.toxml('utf-8')
 2673: 	    match=re.sub(r'<\?xml version=\"1.0\" encoding=\"utf-8\"\?>\n<txt>','',newxml)
 2674: 	    match=re.sub(r'</txt>','',match)
 2675: 	    
 2676: 	    return match
 2677: 			   
 2678:         return ""
 2679: 
 2680:     def xml2html(self,str):
 2681:         """link2html fuer VLP muss hier noch raus"""
 2682:         if str:
 2683: 
 2684:             str=re.sub("\&","&amp;",str)
 2685:             dom=xml.dom.minidom.parseString(str)
 2686:             links=dom.getElementsByTagName("link")
 2687:             
 2688: 
 2689:             for link in links:
 2690:                 link.tagName="a"
 2691:                 ref=link.getAttribute("ref")
 2692:                 if self.checkRef(ref):
 2693:                     link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
 2694: 
 2695:             return dom.toxml('utf-8')
 2696:         return ""
 2697: 
 2698:     def checkRef(self,ref):
 2699:         dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}
 2700:         res=None
 2701:         for db in dbs.keys():
 2702: 
 2703:             res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
 2704:         return res
 2705:                                     
 2706:     #Ende Methode fuer vlp
 2707: 
 2708:     def PgQuoteString(self,string):
 2709:         """Quote string"""
 2710: 
 2711:         return libpq.PgQuoteString(string)
 2712:         
 2713:     def getPartners(self):
 2714:         """Get list of Partners. Presently only from a subfolder partners"""
 2715:                     
 2716:         return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
 2717:                 
 2718:                 
 2719:                    
 2720: 
 2721:     
 2722:     def getPartnersXML(self):
 2723:         """partner liste als xml""" 
 2724:         partners=self.getPartners()
 2725:         ret="""<?xml version="1.0" encoding="utf-8" ?>
 2726: 	<partners>"""
 2727:         
 2728: 	for partner in partners:
 2729:             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),unicode(partner.title,'utf-8','replace'))
 2730: 
 2731:         return ret+"\n</partners>"
 2732:     
 2733:     def getCollectionTree(self):
 2734:         """get the collection tree (list of triples (parent,child, depth)"""
 2735: 
 2736:         def getCollection(object,depth=0):
 2737:             depth+=1
 2738:             collections=[]
 2739:             for entry in object.__dict__.keys():
 2740:                 element=getattr(object,entry)
 2741:                 try:
 2742:                     if element.meta_type=="ECHO_collection":
 2743:                         collections.append((object,element,depth))
 2744:                         collections+=getCollection(element,depth)
 2745:                 except:
 2746:                     """nothing"""
 2747:             return collections
 2748:         
 2749: 
 2750:         return getCollection(self)
 2751:     
 2752:     def getCollectionTreeIds(self):
 2753:         """Show the IDs of the Tree"""
 2754:         ret=[]
 2755:         for collection in self.getCollectionTree():
 2756:             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
 2757:         return ret
 2758: 
 2759:     def getResourcesHTML(self,viewerType=None,filter=None):
 2760: 	    """gebe all ressourcen aus"""
 2761: 
 2762: 	    def sortHTML(x,y):
 2763: 		    return cmp(x[1].title,y[1].title)
 2764: 	    
 2765: 	    ret="""<html><body><h2>Resources in ECHO</h3>"""
 2766: 	    
 2767: 	    resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
 2768: 	    ret+="""<h3>Found %i resources</h3>"""%len(resources)
 2769: 	    resources.sort(sortHTML)
 2770: 	    for resource in resources:
 2771: 		    echo_url=resource[1].absolute_url()
 2772: 		    
 2773: 		    if hasattr(resource[1],'title'):
 2774: 			    title=resource[1].title
 2775: 		    else:
 2776: 			    title="None"
 2777: 		    if filter:
 2778: 			    if re.search(filter,title):
 2779: 				    ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
 2780: 		    else:
 2781: 			    ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
 2782: 
 2783: 	    ret +="""\n</body></html>"""
 2784: 	    
 2785: 	    #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")
 2786: 	    #self.REQUEST.RESPONSE.write(ret)
 2787:     	    return ret
 2788:     
 2789:     def getResourcesXML(self,viewerType=None,filter=None):
 2790: 	    """gebe all ressourcen aus"""
 2791: 	    ret="""<?xml version="1.0" ?>
 2792: 	             <index>"""
 2793: 	    for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
 2794: 
 2795: 		    echo_url=resource[1].absolute_url()
 2796: 		    if hasattr(resource[1],'link'):
 2797: 			    viewer_url=resource[1].link
 2798: 		    else:
 2799: 			    viewer_url="NO URL"
 2800: 		    if filter:
 2801: 			    if re.search(filter,viewer_url):
 2802: 				    ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
 2803: 		    else:
 2804: 			    ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
 2805: 	    ret +="""\n</index>"""
 2806: 	    
 2807: 	    self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
 2808: 	    self.REQUEST.RESPONSE.write(ret)
 2809: 
 2810:     def getFullTextsXML(self,viewerType=None,filter=None):
 2811: 	    """gebe all ressourcen aus"""
 2812: 	    ret="""<?xml version="1.0" ?>
 2813: 	             <index>"""
 2814: 	    for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
 2815: 
 2816: 		    echo_url=resource[1].absolute_url()
 2817: 		    if resource[1].getFullTextXML(noredirect="yes"):
 2818: 			    if hasattr(resource[1],'link'):
 2819: 				    viewer_url=echo_url+"/getFullTextXML"
 2820: 			    else:
 2821: 				    viewer_url="NO URL"
 2822: 			    if filter:
 2823: 				    if re.search(filter,viewer_url):
 2824: 					    ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
 2825: 			    else:
 2826: 				    ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
 2827: 	    ret +="""\n</index>"""
 2828: 	    
 2829: 	    
 2830: 	    self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
 2831: 	    self.REQUEST.RESPONSE.write(ret)
 2832: 
 2833: 
 2834:     def getMetaDatasXML(self,viewerType=None,filter=None):
 2835: 	    """gebe all ressourcen aus"""
 2836: 	    ret="""<?xml version="1.0" ?>
 2837: 	             <index>"""
 2838: 	    for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
 2839: 
 2840: 		    echo_url=resource[1].absolute_url()
 2841: 		    
 2842: 		    if hasattr(resource[1],'link'):
 2843: 			    meta_url=echo_url+"/getMetaDataXML"
 2844: 		    else:
 2845: 			    meta_url="NO_URL"
 2846: 			    
 2847: 		    if filter and not re.search(filter,viewer_url):
 2848: 			    continue
 2849: 
 2850: 		    ret+="""\n<resource resourceLink="%s" metaLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(meta_url,safe='/:?'))
 2851: 			    
 2852: 	    ret +="""\n</index>"""
 2853: 	    
 2854: 	    
 2855: 	    self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
 2856: 	    self.REQUEST.RESPONSE.write(ret)
 2857: 
 2858: 	    
 2859:     def findPartners(self):	
 2860:         """find all partners in partners"""
 2861:         par=self.ZopeFind(self.partners, obj_metatypes='ECHO_partner')
 2862:         return par
 2863:         
 2864:     def getPartnerFromID(self):
 2865:         """find partner form ID return object"""
 2866:         pa=self.REQUEST['partner']
 2867:         par=self.ZopeFind(self.partners, obj_ids=[pa])
 2868:         return par
 2869:         
 2870:     def getPartnerFromIDParameter(self, id):
 2871:         """ find partners from ID"""
 2872:         par=self.ZopeFind(self.partners, obj_ids=[id])
 2873:         return par
 2874: 
 2875: 
 2876:         
 2877: def manage_addECHO_root(self,id,title,RESPONSE=None):
 2878:     """Add an ECHO_root"""
 2879:     self._setObject(id,ECHO_root(id,title))
 2880:     
 2881:     if RESPONSE is not None:
 2882:         RESPONSE.redirect('manage_main')
 2883: 
 2884: def manage_addECHO_rootForm(self):
 2885:         """Nothing yet"""
 2886:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)
 2887:         return pt()
 2888: 
 2889: class ECHO_copyrightType(Folder):
 2890: 	"""copyright typ"""
 2891: 
 2892: 	meta_type="ECHO_copyrightType"
 2893: 	
 2894: 	def __init__(self,id,title,label,url):
 2895: 		"""init"""
 2896: 		self.id=id
 2897: 		self.title=title
 2898: 		self.label=label
 2899: 		self.url=url
 2900: 
 2901: 	manage_options = Folder.manage_options+(
 2902:         {'label':'Main Config','action':'ECHO_copyrightType_config_mainForm'},
 2903: 	)
 2904: 
 2905: 	def ECHO_copyrightType_config_mainForm(self):
 2906: 		"""change form"""
 2907: 		pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_copyrightType').__of__(self)
 2908: 		pt.content_type="text/html"
 2909: 		return pt()
 2910: 
 2911: 	def ECHO_copyrightType_config_main(self,title,label,url,RESPONSE=None):
 2912: 		"""change"""
 2913: 		self.title=title
 2914: 		self.label=label
 2915: 		self.url=url
 2916: 
 2917: 		if RESPONSE is not None:
 2918: 			RESPONSE.redirect('manage_main')
 2919: 
 2920: def manage_addECHO_copyrightTypeForm(self):
 2921:         """Form for adding a ressource"""
 2922:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_copyrightTypeForm.zpt').__of__(self)
 2923:         return pt()
 2924: 
 2925: 
 2926: def manage_addECHO_copyrightType(self,id,title,label,url,RESPONSE=None):
 2927:     """addaresource"""
 2928: 
 2929:     newObj=ECHO_copyrightType(id,title,label,url)
 2930: 
 2931:     self._setObject(id,newObj)
 2932: 
 2933:     if RESPONSE is not None:
 2934:         RESPONSE.redirect('manage_main')
 2935:  
 2936: 
 2937:  
 2938: class ECHO_partner(Image,Persistent):
 2939:     """ECHO Partner"""
 2940: 
 2941:     meta_type="ECHO_partner"
 2942: 
 2943:     def __init__(self, id, title,url, file, copyrightType, person, email, country, color, content_type='', precondition=''):
 2944:         self.__name__=id
 2945:         self.title=title
 2946:         self.url=url
 2947:         self.person=person
 2948:         self.email=email
 2949:         self.country=country
 2950:         self.color=color
 2951:         self.precondition=precondition
 2952:         self.copyrightType=copyrightType
 2953:         data, size = self._read_data(file)
 2954:         content_type=self._get_content_type(file, data, id, content_type)
 2955:         self.update_data(data, content_type, size)
 2956: 
 2957:     manage_options = Image.manage_options+(
 2958:         {'label':'Partner Information','action':'ECHO_partner_config'},
 2959:         )
 2960: 
 2961:     
 2962:     def changeECHO_partner(self,url,copyrightType,person, email, country, color, RESPONSE=None):
 2963:         """Change main information"""
 2964:         self.url=url
 2965:         self.person=person
 2966:         self.email=email
 2967:         self.country=country
 2968:         self.color=color
 2969:         self.copyrightType=copyrightType
 2970:         if RESPONSE is not None:
 2971:             RESPONSE.redirect('manage_main')
 2972:             
 2973:             
 2974: 
 2975:     def ECHO_partner_config(self):
 2976:         """Main configuration"""
 2977:         if not hasattr(self,'url'):
 2978:             self.url=""
 2979:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_partner.zpt').__of__(self)
 2980:         return pt()
 2981: 
 2982:         
 2983: manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
 2984:                              Kind='ECHO_partner',kind='ECHO_partner')
 2985: 
 2986: 
 2987: 
 2988: def manage_addECHO_partner(self, id, url, person, email, country, color, file=None, copyrightType='', title='', precondition='', content_type='',
 2989:                     REQUEST=None):
 2990:     """
 2991:     Add a new ECHO_partner object.
 2992: 
 2993:     Creates a new ECHO_partner object 'id' with the contents of 'file'.
 2994:     Based on Image.manage_addImage
 2995:     """
 2996: 
 2997:     id=str(id)
 2998:     title=str(title)
 2999:     content_type=str(content_type)
 3000:     precondition=str(precondition)
 3001: 
 3002:     id, title = OFS.Image.cookId(id, title, file)
 3003: 
 3004:     self=self.this()
 3005: 
 3006:     # First, we create the image without data:
 3007:     self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, color, content_type, precondition))
 3008: 
 3009:     # Now we "upload" the data.  By doing this in two steps, we
 3010:     # can use a database trick to make the upload more efficient.
 3011:     if file:
 3012:         self._getOb(id).manage_upload(file)
 3013:     if content_type:
 3014:         self._getOb(id).content_type=content_type
 3015: 
 3016:     if REQUEST is not None:
 3017:         try:    url=self.DestinationURL()
 3018:         except: url=REQUEST['URL1']
 3019:         REQUEST.RESPONSE.redirect('%s/manage_main' % url)
 3020:     return id
 3021: 
 3022: