File:  [Repository] / ECHO_content / ECHO_collection.py
Revision 1.157: download - view: text, annotated - select for diffs - revision graph
Thu Aug 5 12:19:30 2004 UTC (19 years, 10 months ago) by jdamerow
Branches: MAIN
CVS tags: HEAD
ECHO_linkList, ECHO_institution, ECHO_support eingefügt

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

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