Return to ECHO_collection.py CVS log

Up to [Repository] / ECHO_content

bugs fixed for changing templates

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