Return to ECHO_collection.py CVS log

Up to [Repository] / ECHO_content

compyrgiht managment added

    1: """New version of the product started February, 8th. Without scientific classification, use content-type for further classification."""
    2: """Echo collection provides the classes for the ECHO content web-site.
    3: 
    4: class ECHO_collection is the basis class for an ECHO collection.
    5: 
    6: class ECHO_resource contains information on ECHO resources (e.g. an Display environment for Metadata
    7: 
    8: class ECHO_externalLink contains information on externalLinks
    9: 
   10: 
   11: """
   12: import string
   13: import re
   14: import os
   15: import OFS.Image
   16: from types import *
   17: from OFS.Image import Image
   18: from Globals import DTMLFile
   19: from OFS.Folder import Folder
   20: from OFS.SimpleItem import SimpleItem
   21: from AccessControl import ClassSecurityInfo
   22: from AccessControl.User import UserFolder
   23: from Globals import InitializeClass
   24: from Globals import DTMLFile
   25: import Globals
   26: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   27: from Products.PageTemplates.PageTemplate import PageTemplate
   28: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   29: from Globals import Persistent, package_home
   30: from Acquisition import Implicit
   31: from ECHO_helpers import displayTypes
   32: 
   33: 
   34: try:
   35: 	from psycopg import libpq
   36: except:
   37: 	try:
   38: 		from pyPgSQL import libpq
   39: 	except:
   40: 		print "ECHO_collection: Warning - No libpq imported!"
   41: 		
   42: import xml.dom.minidom
   43: 
   44: import urllib
   45: import xml.dom.minidom
   46: from ECHO_graphicalOverview import javaHandler,javaScriptMain
   47: import ECHO_helpers
   48: 
   49: #List of different types for the graphical linking viewer
   50: viewClassificationListMaster=['view point','area']
   51: 
   52: def checkDiffs(self,metadict):
   53: 	    """check differences"""
   54: 
   55: 	    
   56: 
   57:     
   58: 	    def NoneToEmpty(obj):
   59: 		    if obj:
   60: 			    return obj
   61: 		    else:
   62: 			    return ""
   63: 
   64: 	    
   65: 	    
   66: 	    diffs={}
   67: 	    
   68: 	    tags=self.findTagsFromMapping(self.contentType)
   69: 	    self.referencetypes=tags[2]
   70: 	    self.fields=tags[3]
   71: 	    
   72:     
   73: 	    for field in tags[1]:
   74: 		    try:
   75: 			    if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
   76: 				    diffs[self.getFieldTag(tags,field)]=1
   77: 			    else:
   78: 				    
   79: 				    diffs[self.getFieldTag(tags,field)]=0
   80: 		    except:
   81: 			    diffs[self.getFieldTag(tags,field)]=0
   82: 			    
   83: 	    return diffs
   84:     
   85: def content_html(self,type):
   86:         """template fuer content"""
   87:         #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
   88:         #
   89:         #if templates:
   90:         #    return templates[0][1]()
   91: 
   92:         try:
   93:             obj=getattr(self,type+"_template")
   94:             return obj()
   95:         except:
   96:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)
   97:             pt.content_type="text/html"
   98:             return pt()
   99:     
  100: def toList(field):
  101:     """Einzelfeld in Liste umwandeln"""
  102:     if type(field)==StringType:
  103:         return [field]
  104:     else:
  105:         return field
  106:     
  107: def getText(nodelist):
  108: 
  109:     rc = ""
  110:     for node in nodelist:
  111:     	if node.nodeType == node.TEXT_NODE:
  112:            rc = rc + node.data
  113:     return rc
  114: 
  115: 
  116: def sendFile(self, filename, type):
  117:     """sends an object or a local file (in the product) as response"""
  118:     paths = filename.split('/')
  119:     object = self
  120:     # look for an object called filename
  121:     for path in paths:
  122:         if hasattr(object, path):
  123: 	    object = getattr(object, path)
  124: 	else:
  125: 	    object = None
  126: 	    break
  127:     if object:
  128: 	# if the object exists then send it
  129: 	return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
  130:     else:
  131: 	# send a local file with the given content-type
  132: 	fn = os.path.join(package_home(globals()), filename)
  133: 	self.REQUEST.RESPONSE.setHeader("Content-Type", type)
  134: 	self.REQUEST.RESPONSE.write(file(fn).read())
  135:     return
  136: 
  137: class BrowserCheck:
  138:     """check the browsers request to find out the browser type"""
  139:     
  140:     def __init__(self, zope):
  141: 	self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")
  142: 	self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and (string.find(self.ua, 'MSIE') < 0)
  143: 	self.isIE = string.find(self.ua, 'MSIE') > -1
  144: 	self.nav = self.ua[string.find(self.ua, '('):]
  145: 	ie = string.split(self.nav, "; ")[1]
  146: 	if string.find(ie, "MSIE") > -1:
  147: 	    self.versIE = string.split(ie, " ")[1]
  148: 	self.isMac = string.find(self.ua, 'Macintosh') > -1
  149: 	self.isWin = string.find(self.ua, 'Windows') > -1
  150: 	self.isIEWin = self.isIE and self.isWin
  151: 	self.isIEMac = self.isIE and self.isMac
  152: 
  153: 
  154: def writeMetadata(url,metadict):
  155: 	"""Einlesen der Metadaten und und erstellen des geaenderten XML file"""
  156: 
  157: 	try:
  158: 		geturl=""
  159: 		for line in urllib.urlopen(url).readlines():
  160: 			geturl=geturl+line
  161:         
  162:         
  163: 	except:
  164: 		return (None,"Cannot open: "+url)
  165: 
  166: 	try:
  167: 		dom=xml.dom.minidom.parseString(geturl)
  168: 	except:
  169: 		return (None,"Cannot parse: "+url+"<br>"+geturl)
  170: 
  171: 	metanodes=dom.getElementsByTagName('bib')
  172: 
  173: 	if not metanodes:
  174: 		metanodes=dom.getElementsByTagName('archimedes')
  175: 
  176: 	metanode=metanodes[0]
  177: 
  178: 	for metaData in metadict.keys():
  179: 		
  180: 		try:
  181: 			nodeOld=metanode.getElementsByTagName(metaData)
  182: 		except:
  183: 			nodeOld=None
  184: 			
  185: 		if nodeOld:
  186: 			metanode.removeChild(nodeOld[0]).unlink()
  187: 		else:
  188: 			# try also old writing rule - instead of _:
  189: 			try:
  190: 				nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
  191: 			except:
  192: 				nodeOld=None
  193: 				
  194: 			if nodeOld:
  195: 				metanode.removeChild(nodeOld[0]).unlink()
  196: 
  197: 		metanodeneu=dom.createElement(metaData)
  198: 		try:
  199: 			metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8"))
  200: 		except:
  201: 			metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8'))
  202: 		metanodeneu.appendChild(metanodetext)
  203: 		metanode.appendChild(metanodeneu)
  204: 
  205: 	
  206: 	return dom.toxml().encode('utf-8')
  207: 
  208: 	
  209: 	
  210: def readMetadata(url):
  211:     """Methode zum Auslesen der Metadateninformation zu einer Resource
  212:     Vorerst noch Typ bib"""
  213:     
  214:     metadict={}
  215:     try:
  216:         geturl=""
  217:         for line in urllib.urlopen(url).readlines():
  218:             geturl=geturl+line
  219:         
  220:         
  221:     except:
  222:         return (None,"Cannot open: "+url)
  223: 
  224:     try:
  225:         dom=xml.dom.minidom.parseString(geturl)
  226:     except:
  227:         return (None,"Cannot parse: "+url+"<br>"+geturl)
  228: 
  229:     metanode=dom.getElementsByTagName('bib')
  230:     metadict['bib_type']='Book'
  231:     if len(metanode)==0:
  232:         metanode=dom.getElementsByTagName('archimedes')
  233:         metadict['bib_type']='Archimedes'
  234:         
  235:         
  236:     if not len(metanode)==0:    
  237:         metacontent=metanode[0].childNodes
  238:     
  239:         try:
  240:             metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
  241:         except:
  242:             """nothing"""
  243:         
  244:         for node in metacontent:
  245:             try:
  246: 		    metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes))
  247:             except:
  248:                 """nothing"""
  249: 
  250: 
  251:     return metadict,""
  252:     
  253: 
  254: def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):
  255: 
  256:         """Allegemeine Informationen zu einer ECHO Collection"""
  257: 
  258:         self.viewClassification=viewClassification
  259: 
  260:         self.label = label
  261:         self.title=title
  262:         self.description=description
  263:         self.contentType=contentType
  264:         self.responsible=responsible
  265:         self.credits=toList(credits)
  266:         self.weight=weight
  267: 
  268:         coords=[]
  269:         #coordinates of for rectangles
  270: 
  271:         
  272:         if coordstrs:
  273:             for coordstr in coordstrs:
  274:         
  275:                 try:
  276:                     temco=coordstr.split(",")
  277:                 except:
  278:                     temco=[]
  279:         
  280:                 coords.append(temco)
  281: 
  282: 
  283:         self.coords=coords[0:]
  284:             
  285: 
  286: class scientificClassification(SimpleItem,Persistent,Implicit):
  287:     """outdated will be deleeted in the next versions: subclass"""
  288:     security=ClassSecurityInfo()
  289:     
  290:     def __init__(self,context,science,practice):
  291:         self.context=context
  292:         self.science=science
  293:         self.practice=practice
  294:         self.id="scientific_Classification"
  295:         
  296:     security.declarePublic('get_context')
  297:     def get_context(self):
  298:         return self.context
  299:     
  300:     security.declarePublic('get_science')
  301:     def get_science(self):
  302:         return self.science
  303:         
  304:     security.declarePublic('get_practice')
  305:     def get_practice(self):
  306:         return self.practice
  307:     
  308:                 
  309: class scientificInformation(Folder,Persistent,Implicit):
  310:     """outdated will be deleted in the next versions: subclass scientificInformation"""
  311:     security=ClassSecurityInfo()
  312:     
  313:     
  314:     
  315:     def __init__(self,source_type,period):
  316: 
  317:         self.id="scientific_Information"
  318:         self.source_type=source_type
  319:         self.period=period
  320:         
  321: 
  322: 
  323:     security.declarePublic('get_source_type')
  324:     def get_source_type(self):
  325:         return self.source_type
  326:     
  327:     security.declarePublic('get_period')
  328:     def get_period(self):
  329:         return self.period
  330: 
  331: class ECHO_layoutTemplate(ZopePageTemplate):
  332:     """Create a layout Template for different purposes"""
  333: 
  334:     meta_type="ECHO_layoutTemplate"
  335: 
  336:     def __init__(self, id, text=None, content_type=None,EchoType=None):
  337:         self.id = str(id)
  338: 
  339: 
  340: 
  341:         self.ZBindings_edit(self._default_bindings)
  342:         if text is None:
  343:             self._default_content_fn = os.path.join(package_home(globals()),
  344:                                                'zpt/ECHO_%s_template_standard.zpt'%EchoType)
  345:             text = open(self._default_content_fn).read()
  346:         self.pt_edit(text, content_type)
  347: 
  348:     
  349:         """change form"""
  350: 
  351: 
  352: def manage_addECHO_layoutTemplateForm(self):
  353:     """Form for adding"""
  354:     pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_layoutTemplate.zpt').__of__(self)
  355:     return pt()
  356: 
  357: from urllib import quote
  358: 
  359: 
  360: def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
  361:     "Add a Page Template with optional file content."
  362:     if type(EchoType)==StringType:
  363:         EchoTypes=[EchoType]
  364:     else:
  365:         EchoTypes=EchoType
  366:         
  367:     for singleType in EchoTypes:
  368: 
  369:         id = str(singleType)+"_template"
  370:         if REQUEST is None:
  371:             self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))
  372:             ob = getattr(self, id)
  373:             
  374:             if title:
  375:                 ob.pt_setTitle(title)
  376:             return ob
  377:         else:
  378:             file = REQUEST.form.get('file')
  379:             headers = getattr(file, 'headers', None)
  380:             if headers is None or not file.filename:
  381:                 zpt = ECHO_layoutTemplate(id,EchoType=singleType)
  382:             else:
  383:                 zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))
  384: 
  385:             self._setObject(id, zpt)
  386:             ob = getattr(self, id)
  387:             if title:
  388:                 ob.pt_setTitle(title)
  389: 
  390:             try:
  391:                 u = self.DestinationURL()
  392:             except AttributeError:
  393:                 u = REQUEST['URL1']
  394: 
  395:             
  396:     REQUEST.RESPONSE.redirect(u+'/manage_main')
  397:     return ''
  398: 
  399: class ECHO_resource(Folder,Persistent):
  400:     """ECHO Ressource"""
  401:     meta_type='ECHO_resource'
  402: 
  403:     viewClassificationList=viewClassificationListMaster
  404: 
  405:     getSubCols = ECHO_helpers.getSubCols
  406:     def getTitle(self):
  407: 	"""title"""
  408: 	return self.title.encode('utf-8') 
  409: 
  410:     def getLabel(self):
  411: 	"""title"""
  412: 	return self.label.encode('utf-8') 
  413: 
  414:     def content_html(self):
  415:         """template fuer content"""
  416:         return content_html(self,'resource')
  417:     
  418:     def getViewClassification(self):
  419:         if hasattr(self,'viewClassification'):
  420:             return self.viewClassification
  421:         else:
  422:             return ""
  423: 
  424:     def getFullTextXML(self,noredirect=None):
  425: 	    """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
  426: 	    try:
  427: 		    fh=urllib.urlopen(self.metalink)
  428: 		    dom=xml.dom.minidom.parse(fh)
  429: 		    texttools=dom.getElementsByTagName('texttool')
  430: 		    text=texttools[0].getElementsByTagName('text')
  431: 		    texturl=getText(text[0].childNodes)
  432: 		    self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
  433: 		    if not noredirect:
  434: 			    self.REQUEST.RESPONSE.redirect(texturl)
  435: 		    else:
  436: 			    return texturl
  437: 	    except:
  438: 
  439: 		    if not noredirect:
  440: 			    self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
  441: 			    self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
  442: 		    else:
  443: 			    return "<error>no fulltext available</error>"
  444: 
  445:     def getCopyright(self):
  446: 	    """gib link auf copyright notiz aus"""
  447: 	    if hasattr(self,'copyrightType'):
  448: 		    obj=getattr(self.copyrightTypes,'copyrightType')
  449: 	    else:
  450: 		    obj=getattr(self.copyrightTypes,'generic')
  451: 
  452: 	    label=obj.label
  453: 	    link="copyrightTypes/"+obj.getId()+'/copyright.html'
  454: 	    
  455: 	    return """<a target="_blank" href="%s">c%s</a>"""%(link,label)
  456:     
  457:     def getCredits(self):
  458:         """Ausgabe der credits"""
  459:         if self.credits:
  460:             return self.credits
  461:         else:
  462:             return []
  463:     
  464:     def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
  465: 
  466:         self.id = id
  467:         """Festlegen der ID"""
  468:         
  469:         self.label = label
  470:         self.link= link
  471:         self.metalink=metalink
  472:         self.title=title
  473:         self.weight=weight
  474:         self.credits=toList(credits)
  475:         self.description=description
  476:         self.contentType=contentType
  477: 	self.copyrightType=copyrightType
  478: 	self.renderingType=renderingType
  479:         self.responsible=responsible
  480:         self.resourceID=resourceID
  481: 	
  482:         if coords:
  483:             coordsnew=[ string.split(x,",") for x in coords]
  484:         else:
  485:             coordsnew=[]
  486:         
  487:         self.coords=coordsnew
  488: 
  489: 
  490:     def getCoords(self):
  491: 	    """gibt coordinaten als String zurück und löscht zugleich einträge die keine Koordinaten sind, letzteres zur korrektur der Eingabe der alten version"""
  492: 	    retList=[]
  493: 	    if hasattr(self,'coords'):
  494: 		    for x in self.coords:
  495: 			if len(x)>1:
  496: 				retList.append(string.join(x,","))
  497: 	    return retList
  498: 
  499:     
  500: 
  501:     def getContentType(self):
  502: 	    try:
  503: 		    return self.contentType
  504: 	    except:
  505: 		    return ""
  506: 
  507:     def getCopyrightType(self):
  508: 	    try:
  509: 		    return self.copyrightType
  510: 	    except:
  511: 		    return ""
  512: 
  513:     def getRenderingType(self):
  514: 	    try:
  515: 		    return self.renderingType
  516: 	    except:
  517: 		    return ""
  518: 
  519:     def ECHO_resource_config(self):
  520:         """Main configuration"""
  521: 
  522:         if not hasattr(self,'weight'):
  523:             self.weight=""
  524: 
  525:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)
  526:         return pt()
  527:     
  528: 
  529:     def ECHO_resource_config_main(self):
  530:         """Main configuration"""
  531: 
  532:         if not hasattr(self,'weight'):
  533:             self.weight=""
  534: 
  535:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)
  536:         return pt()
  537: 
  538:     def ECHO_resource_config_coords(self):
  539:         """Coords configuration """
  540: 
  541:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_coords.zpt').__of__(self)
  542:         return pt()
  543: 
  544:     def ECHO_resource_config_credits(self):
  545:         """Main configuration"""
  546: 
  547:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)
  548:         return pt()
  549: 
  550:     def ECHO_resource_config_metadata(self):
  551:         """Main configuration"""
  552: 
  553: 	if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
  554: 		self.metaDataHash={}
  555: 		self.contentType=self.bib_type
  556: 		for data in self.metadata:
  557: 			data_neu=re.sub('-','_',data)
  558: 			self.metaDataHash[data_neu]=getattr(self,data)
  559: 
  560: 	
  561:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)
  562:         return pt()
  563: 
  564: 
  565:     
  566: 
  567:     def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):
  568:         """Änderung der Properties"""
  569: 	self.resourceID=resourceID
  570: 	self.title=title
  571: 	self.label=label
  572: 	self.description=description
  573: 
  574: 	self.contentType=contentType
  575: 	self.renderingType=renderingType
  576: 	self.weight=weight
  577: 	
  578:         self.link=link
  579:         self.metalink=metalink
  580:         
  581:         if RESPONSE is not None:
  582:             RESPONSE.redirect('manage_main')
  583: 
  584: 
  585:     def changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):
  586:         """Änderung der Properties - coords"""
  587: 
  588: 	if type(coords)==StringType:
  589:         	coords=[coords]
  590: 
  591:        	try:        
  592:         	coordsnew=[ string.split(x,",") for x in coords]
  593:         except:
  594: 		coordsnew=[]	
  595: 
  596: 	self.coords=coordsnew[0:]
  597: 	self.viewClassification=viewClassification
  598:         
  599:         if RESPONSE is not None:
  600:             RESPONSE.redirect('manage_main')
  601: 
  602:     def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
  603:         """Änderung der Properties"""
  604: 	self.credits=credits
  605: 	self.responsible=responsible
  606: 	self.copyrightType=copyrightType
  607:         
  608:         if RESPONSE is not None:
  609:             RESPONSE.redirect('manage_main')
  610: 
  611: 
  612:     def changeECHO_resource_metadata_local(self,RESPONSE=None):
  613: 	    """change metadata"""
  614: 	    tags=self.findTagsFromMapping(self.contentType)
  615: 	    for field in tags[1]:
  616: 		    self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
  617: 			
  618: 
  619: 	    	    
  620: 	    if RESPONSE is not None:
  621: 		    RESPONSE.redirect('manage_main')
  622: 
  623:     def changeECHO_resource_metadata(self,RESPONSE=None):
  624: 	    """change metadata"""
  625: 	    tags=self.findTagsFromMapping(self.contentType)
  626: 	    self.OSAS_meta={}
  627: 	    for field in tags[1]:
  628: 		    try:
  629: 			    self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
  630: 			    self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
  631: 		    except:
  632: 			    """nothing"""
  633: 
  634: 	    return 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()
  635: 	    
  636: 	    if RESPONSE is not None:
  637: 		    RESPONSE.redirect('manage_main')
  638: 
  639: 
  640:     def getMDValue(self,fieldName):
  641: 	    return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)
  642: 					 
  643:     def newMetaXML(self):
  644: 	    """new index.meta"""
  645: 	    self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
  646: 	    return writeMetadata(self.metalink,self.OSAS_meta)
  647: 
  648: 
  649:     def getMetaDataXML(self):
  650: 	    """prints out metadata as stored in the echo environment, format is the index.meta format"""
  651: 	    self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
  652: 	    return writeMetadata(self.metalink,self.metaDataHash)
  653: 
  654:     def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):
  655:         """Änderung der Properties"""
  656:         
  657: 	try:        
  658:         	coordsnew=[ string.split(x,",") for x in coords]
  659:         except:
  660: 		coordsnew=[]	
  661:         
  662:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
  663: 	self.viewClassification=viewClassification
  664:         self.coords=coordsnew[0:]
  665:         self.link=link
  666:         self.metalink=metalink
  667:         
  668:         if RESPONSE is not None:
  669:             RESPONSE.redirect('manage_main')
  670:             
  671:             
  672:     manage_options = Folder.manage_options+(
  673:         {'label':'Main Config','action':'ECHO_resource_config_main'},
  674: 	{'label':'Change Credits & Copyright','action':'ECHO_resource_config_credits'},
  675: 	{'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
  676: 	{'label':'Change Coords','action':'ECHO_resource_config_coords'},
  677: 	{'label':'Add coords','action':'ECHO_graphicEntry'},
  678:         {'label':'Sync Metadata','action':'ECHO_getResourceMD'},
  679: 	)
  680: 
  681:     def getOverview(self):
  682:         """overview graphics"""
  683:         
  684:         return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
  685: 
  686:     def ECHO_graphicEntry(self):
  687:         """DO nothing"""
  688:         overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
  689:         if overview: 
  690:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
  691:             return pt()
  692:         else:
  693:             return "NO OVERVIEW GRAPHICS"
  694: 
  695:     def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
  696:         """Enter coords"""
  697:         coords=self.coords
  698:         temco=coordstr.split(",")
  699:         temco.append(angle)
  700:         coords.append(temco)
  701:         
  702:         self.coords=coords[0:]
  703: 
  704:         if RESPONSE is not None:
  705:             RESPONSE.redirect('ECHO_graphicEntry')
  706: 
  707: 
  708:     def isDefinedInThisSet(self,fields,field):
  709: 	    """checks if field is defined in fields"""
  710: 	    if (fields[0].has_key(field)) and not (fields[0][field]==""):
  711: 		    return 1
  712: 	    else:
  713: 		  
  714: 		    return 0
  715: 	    
  716:     def getFieldLabel(self,fields,field):
  717:         """get labels"""
  718:         try:
  719:             ret =fields[0][field]
  720:             if ret == "":
  721:                 return field
  722:             else:
  723:                 return ret
  724:         except:
  725:             return field
  726: 
  727: 
  728: 
  729:     def getFieldTag(self,fields,field):
  730:         """get labels"""
  731:         try:
  732:             ret =fields[0][field]
  733:             if ret == "":
  734:                 return field
  735:             else:
  736:                 return ret
  737:         except:
  738:             return field
  739: 
  740:     
  741:         
  742:     def getFieldValue(self,field):
  743:         """get value"""
  744: 	
  745:         try:
  746: 	
  747:             ret=self.metaDataHash[field]
  748:             if ret == "":
  749:                 return None
  750:             else:
  751:                 return ret
  752:         except:
  753:             return None
  754: 
  755:     def getMetaDataHash(self):
  756: 	    """md hash"""
  757: 	    return self.metaDataHash
  758:     
  759:     def setFieldValue(self,field,value):
  760:         """get value"""
  761: 	
  762: 	if not hasattr(self,'metaDataHash'):
  763: 		setattr(self,'metaDataHash',{})
  764: 	self.metaDataHash[field]=value[0:]
  765: 	
  766: 
  767: 
  768:     def findLabelsFromMapping(self,referenceType):
  769:         """gib hash mit label -> generic zurueck"""
  770: 	#return {},[]
  771: 
  772:         temp=self.ZopeFind(self.standardMD)
  773: 
  774: 	if referenceType=="":
  775: 		referenceType="book"
  776: 	
  777: 	
  778:         bibdata={}
  779:         retdata={}
  780: 	fields=[]
  781:         fieldlist=self.standardMD.fieldList
  782:         
  783: 	for referenceTypeF in self.referencetypes:
  784: 
  785: 		if referenceTypeF[1].title.lower() == referenceType.lower():
  786: 
  787: 			try:
  788: 				bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
  789: 				referenceType=referenceTypeF[1].title
  790: 			except:
  791: 				bibdata[referenceType]=referenceTypeF[1].fields
  792: 		
  793: 
  794: 			bibdata['data']=referenceTypeF[1]
  795: 			fields=bibdata[referenceType]
  796:                         for field in fieldlist:
  797:                             retdata[field]=referenceTypeF[1].getValue(field)[1]
  798: 
  799:         return retdata,fieldlist,temp,fields
  800: 
  801:     def findTagsFromMapping(self,referenceType):
  802:         """gib hash mit label -> generic zurueck"""
  803: 	
  804: 
  805: 	if referenceType=="":
  806: 		referenceType="book"
  807: 	
  808: 	temp =  self.ZopeFind(self.standardMD)[0:]
  809: 
  810: 	
  811: 	#self.referencetypes=temp[0:]
  812: 	
  813: 	
  814: 	
  815: 
  816: 	
  817: 
  818:         bibdata={}
  819:         retdata={}
  820:         fieldlist=self.standardMD.fieldList
  821:         
  822: 	for referenceTypeF in temp:
  823: 	
  824: 		if referenceTypeF[1].title.lower() == referenceType.lower(): 
  825: 			try:
  826: 				bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
  827: 				referenceType=referenceTypeF[1].title
  828: 			except:
  829: 				bibdata[referenceType]=referenceTypeF[1].fields
  830: 			bibdata['data']=referenceTypeF[1]
  831: 			fields=bibdata[referenceType]
  832:                         for field in fieldlist:
  833:                             retdata[field]=referenceTypeF[1].getValue(field)[0]
  834: 	
  835:         return retdata,fieldlist,temp,fields
  836: 
  837:     
  838: 
  839:     def copyIndex_meta2echo_resource(self,RESPONSE=None):
  840: 	    """copy MD von Index_meta to the echo_resource"""
  841: 
  842: 	    (metadict, error)=readMetadata(self.metalink)
  843: 	    
  844: 	    self.metaDataHash={}
  845: 	    if not error=="": #Fehler beim Auslesen des Metafiles
  846: 		    return "ERROR:",error
  847: 	    fields=self.findTagsFromMapping(self.contentType)
  848: 	    #fields=self.findLabelsFromMapping(self.contentType)
  849: 	    for field in fields[1]:
  850: 		    if self.isDefinedInThisSet(fields,field):
  851: 			    self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))
  852: 
  853: 	    
  854: 	    
  855: 	    if RESPONSE:
  856: 		    return RESPONSE.redirect('manage_main')
  857: 	    
  858:     def ECHO_getResourceMD(self,template="yes"):
  859:         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
  860:         (metadict, error)=readMetadata(self.metalink)
  861: 
  862: 	
  863: 
  864:         if not error=="": #Fehler beim Auslesen des Metafiles
  865: 		return "ERROR:",error
  866: 	
  867: 
  868: 	if not (metadict['bib_type'].lower()==self.contentType.lower()):
  869: 		self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
  870: 		self.REQUEST.SESSION['contentZope']=self.contentType
  871: 
  872: 		return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()
  873: 
  874: 	self.REQUEST.SESSION['metadict']=metadict
  875: 
  876: 	
  877: 	
  878: 	self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])
  879: 	
  880: 
  881: 		
  882:         if template=="yes":
  883: 		pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)
  884: 		return pt()
  885: 
  886: 	
  887: 
  888:     
  889:     
  890:     def ECHO_getMD(self,item):
  891:         """Ausgabe der MD"""
  892:         return getattr(self,item)
  893:         
  894:     def index_html(self):
  895:         """standard page"""
  896:         
  897:         return self.REQUEST.RESPONSE.redirect(self.link)
  898: 
  899:     def startpage_html(self):
  900: 	    """prints out a startpage for a resource for use e.g. in the BVE"""
  901: 
  902: 	    # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt
  903: 
  904: 	    sp=self.ZopeFind(self,obj_ids=['startpage.html'])
  905: 
  906: 	    if sp:
  907: 		    return sp[1]()
  908: 
  909:             #prüfen ob irgendwo ein template
  910: 	    if hasattr(self,'startpage_index_template'): 
  911: 		    return self.startpage_index_template()
  912: 
  913: 	    #generisches template ausgeben
  914: 	    
  915: 	    pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_startpage_index_template_standard.zpt').__of__(self)
  916: 	    pt.content_type="text/html"
  917: 	    return pt()
  918: 
  919:     def toc_html(self):
  920: 	    
  921: 	    sp=self.ZopeFind(self,obj_ids=['toc.html'])
  922: 		    
  923: 	    if sp:
  924: 		    return sp[0][1]()
  925: 
  926: 
  927: 		    
  928:     def generate_label(self):
  929:         """Erzeugt_standard_Label aus Template"""
  930:         pt=getattr(self,"label_template_"+self.bib_type)
  931: 
  932:         return pt()
  933: 
  934:     def generate_title(self,RESPONSE=None):
  935:         """Erzeugt_standard_Label aus Template"""
  936:         pt=getattr(self,"label_template_"+self.contentType)
  937: 
  938: 	self.title=pt()
  939: 	
  940:         return pt()
  941: 
  942: def manage_addECHO_resourceForm(self):
  943:         """Form for adding a ressource"""
  944:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)
  945:         return pt()
  946: 
  947: 
  948: 
  949: 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):
  950:     """addaresource"""
  951: 
  952:     newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
  953: 
  954:     self._setObject(id,newObj)
  955: 
  956:     if RESPONSE is not None:
  957:         RESPONSE.redirect('manage_main')
  958:  
  959: 
  960: class ECHO_externalLink(Folder):
  961:     """Link zu einer externen Ressource"""
  962:     security=ClassSecurityInfo()
  963:     meta_type='ECHO_externalLink'
  964: 
  965:     def getTitle(self):
  966: 	"""title"""
  967: 	return self.title.encode('utf-8') 
  968: 
  969:     def getLabel(self):
  970: 	"""title"""
  971: 	return self.label.encode('utf-8') 
  972: 
  973:     def content_html(self):
  974:         """template fuer content"""
  975:         return content_html(self,'externalLink')
  976:     
  977:     def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
  978: 
  979:         self.id = id
  980:         """Festlegen der ID"""
  981: 
  982:         self.credits=toList(credits)
  983:         self.label = label
  984:         self.link= link
  985:         self.title=title
  986:         self.weight=weight
  987:         self.description=description
  988:         self.contentType=contentType
  989:         self.responsible=responsible
  990:         coordsnew=[ string.split(x,",") for x in coords]
  991:         self.coords=coordsnew
  992: 
  993:     def ECHO_externalLink_config(self):
  994:         """Main configuration"""
  995: 
  996:         if not hasattr(self,'weight'):
  997:             self.weight=""
  998:         if not hasattr(self,'coords'):
  999:             
 1000:             self.coords=['']
 1001: 
 1002: 
 1003:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)
 1004:         return pt()
 1005:     
 1006: 
 1007:     def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
 1008: 
 1009:         """Änderung der Properties"""
 1010: 	try:
 1011: 		coordsnew=[ string.split(x,",") for x in coords]
 1012: 	except:
 1013: 		coordsnew=[]
 1014: 
 1015:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)
 1016: 
 1017:         self.coords=coordsnew[0:]
 1018:         self.link=link
 1019:         if RESPONSE is not None:
 1020:             RESPONSE.redirect('manage_main')
 1021:             
 1022:             
 1023:     manage_options = Folder.manage_options+(
 1024:         {'label':'Main Config','action':'ECHO_externalLink_config'},
 1025:         )
 1026: 
 1027:     def getCredits(self):
 1028:         """Ausgabe der credits"""
 1029:         if self.credits:
 1030:             return self.credits
 1031:         else:
 1032:             return []
 1033:         
 1034:     def index_html(self):
 1035:         """standard page"""
 1036:         
 1037:         return self.REQUEST.RESPONSE.redirect(self.link)
 1038: 
 1039: def manage_addECHO_externalLinkForm(self):
 1040:         """Form for external Links"""
 1041:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)
 1042:         return pt()
 1043: 
 1044: 
 1045: def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
 1046:     """Add an external Link"""
 1047: 
 1048:     newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)
 1049: 
 1050:     self._setObject(id,newObj)
 1051: 
 1052:     if RESPONSE is not None:
 1053:         RESPONSE.redirect('manage_main')
 1054:  
 1055: 
 1056: class ECHO_link(ECHO_externalLink):
 1057: 	"""external_link"""
 1058: 
 1059: 	meta_type="ECHO_link"
 1060: 	
 1061: 
 1062: 	def content_html(self):
 1063: 		"""template fuer link"""
 1064: 		if hasattr(self,"link_template"):
 1065: 			return content_html(self,'link')
 1066: 		else:
 1067: 			return content_html(self,'collection')
 1068: 	
 1069: def manage_addECHO_linkForm(self):
 1070:         """Form for external Links"""
 1071:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)
 1072:         return pt()
 1073: 
 1074: 
 1075: def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
 1076:     """Add an external Link"""
 1077: 
 1078:     newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)
 1079: 
 1080:     self._setObject(id,newObj)
 1081: 
 1082:     if RESPONSE is not None:
 1083:         RESPONSE.redirect('manage_main')
 1084: 	
 1085: 
 1086: class ECHO_collection(Folder, Persistent, Implicit):
 1087:     """ECHO Collection"""
 1088: 
 1089:     security=ClassSecurityInfo()
 1090:     meta_type='ECHO_collection'
 1091:     viewClassificationList=viewClassificationListMaster
 1092:     displayTypes=displayTypes
 1093: 
 1094:     def getViewClassification(self):
 1095:         if hasattr(self,'viewClassification'):
 1096:             return self.viewClassification
 1097:         else:
 1098:             return ""
 1099: 
 1100:     def getTitle(self):
 1101: 	"""title"""
 1102: 	return self.title.encode('utf-8') 
 1103: 
 1104:     def getLabel(self):
 1105: 	"""title"""
 1106: 	return self.label.encode('utf-8') 
 1107: 
 1108:     
 1109: 	    
 1110:     def createRessourcesFromXMLForm(self):
 1111: 	    """form"""
 1112: 	    pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)
 1113: 	    return pt()
 1114: 
 1115:     def createRessourcesFromXML(self,fileupload):
 1116: 	    """read an XML file for generating resources"""
 1117: 	    dom=xml.dom.minidom.parse(fileupload)
 1118: 	    ret="<h2>Added</h2>"
 1119: 	    for resource in dom.getElementsByTagName('resource'):
 1120: 		    link=getText(resource.getElementsByTagName('link')[0].childNodes)
 1121: 		    label=getText(resource.getElementsByTagName('label')[0].childNodes)
 1122: 		    #splitted=link.split("?")[0].split("/")
 1123: 		    #id=splitted[len(splitted)-1].encode('ascii')
 1124: 		    id=re.sub(" ","_",label).encode('ascii')
 1125: 		    
 1126: 		    ret+="<p>"+label+"</p>"
 1127: 		    manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","")
 1128: 	    return ret
 1129:     def getImageTag(self):
 1130:         """GetTag"""
 1131:         try:
 1132:             return self.imageTag
 1133:         except:
 1134:             return ""
 1135: 
 1136:     def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
 1137:         """SSS"""
 1138:         try:
 1139:             manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
 1140:             return "done"
 1141:         except:
 1142:             return None
 1143: 
 1144:     def getSecondaryLink(self):
 1145:         """secondary link"""
 1146:         try:
 1147:             return self.secondaryLink
 1148:         except:
 1149:             return ""
 1150: 
 1151:     def getSecondaryLinkTitle(self):
 1152:         """secondary link"""
 1153:         try:
 1154:             return self.secondaryLinkTitle
 1155:         except:
 1156:             return ""
 1157:         
 1158:     def getCollectionTreeXML(self):
 1159:         """Tree as XML"""
 1160: 
 1161:         def getCollection(object,depth=0):
 1162:             depth+=1
 1163:             collections=""
 1164:             for entry in object.__dict__.keys():
 1165:                 element=getattr(object,entry)
 1166:                 try:
 1167:                     if element.meta_type in ["ECHO_collection","ECHO_group"]:
 1168:                         collections+="<element name=\""+quote(element.title)+"\" url=\""+element.absolute_url()+"\">"
 1169:                         collections+=getCollection(element,depth)+"</element>\n"
 1170:                 except:
 1171:                     """nothing"""
 1172:             return collections
 1173:         
 1174: 	ret="""<?xml version="1.0" encoding="utf-8" ?>"""
 1175:         return ret+"<collection>"+getCollection(self)+"</collection>"
 1176:     
 1177:     def createJavaScript(self):
 1178:         """OLD CreateJava"""
 1179:         ret=javaScriptMain
 1180: 
 1181:         dynamical="\n"
 1182:         for ob in self.getGraphicCoords():
 1183: 	    if ob[4][4] == "":	
 1184: 	        dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])
 1185: 	    else:
 1186: 		dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])
 1187: 		dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])
 1188: 	ret+=javaHandler%dynamical
 1189:         return ret
 1190: 
 1191:     def createJSAreas(self):
 1192:         """create area calls for JavaScript"""
 1193:         dynamical="\n"
 1194:         for ob in self.getGraphicCoords():
 1195: 	    if ob[5] == "area":
 1196: 	        dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob[1],ob[0])
 1197: 	    else:
 1198: 	        dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob[1],ob[0])
 1199:         return dynamical
 1200: 
 1201:     def createMapHead(self):
 1202:         """create javascript include and script tags for head"""
 1203:         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)
 1204:         return pt()
 1205: 
 1206:     def createMapImg(self):
 1207: 	"""generate img-tag for map"""
 1208: 	bt = BrowserCheck(self)
 1209: 	tag = ""
 1210: 	src = self.REQUEST['URL1'] + "/overview"
 1211: 	if bt.isN4:
 1212: 	    tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src
 1213: 	else:
 1214: 	    tag += '<img id="overview" src="%s" />'%src
 1215: 	return tag
 1216:         
 1217:     def createMapLink(self, ob, text=None):
 1218: 	"""generate map link"""
 1219: 	bt = BrowserCheck(self)
 1220: 	id = ob[1]
 1221: 	link = ob[1]
 1222: 	if text == None:
 1223: 	    text = ob[2]
 1224: 	tag = ""
 1225: 	if bt.isN4:
 1226: 	    tag += '<ilayer id="a.%s"><a onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
 1227: 	    tag += ">" + text + "</a></ilayer>"
 1228: 	else:
 1229: 	    tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
 1230: 	    if ob[3].contentType == 'text-popup':
 1231: 		tag += ' title="%s"'%ob[3].description
 1232: 	    tag += ">" + text + "</a>"
 1233: 	return tag
 1234: 
 1235:     def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil"):
 1236: 	"""generate map link image, text and other stuff"""
 1237: 	id = ob[1]
 1238: 	link = ob[1]
 1239: 	vtype = ob[5]
 1240: 	ctype = ob[3].contentType
 1241: 	bt = BrowserCheck(self)
 1242: 	tag = ""
 1243: 
 1244: 	if bt.isN4:
 1245: 	    tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)
 1246: 	    if vtype == "view point":
 1247: 	        rot = ob[4][4]
 1248: 		tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,arrowsrc,rot)
 1249: 	    else:
 1250: 		tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)
 1251: 		if ctype == "text-popup":
 1252: 		    desc = ob[3].description
 1253: 		    tag += ' alt="%s"'%desc
 1254: 		tag += ' /></a>'
 1255: 	    tag += '</layer>'
 1256: 	else:
 1257: 	    tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)
 1258: 	    if vtype == "view point":
 1259: 		rot = ob[4][4]
 1260: 		if bt.isIEWin and bt.versIE > 5:
 1261: 		    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)
 1262: 		else:
 1263: 		    tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,arrowsrc,rot)
 1264: 	    else:
 1265: 		if bt.isIEWin:
 1266: 		    tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;background:url(area_img)"'%(id)
 1267: 		else:
 1268: 		    tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
 1269: 		if ctype == "text-popup":
 1270: 		    desc = ob[3].description
 1271: 		    tag += ' title="%s"'%desc
 1272: 		tag += '> </div>'
 1273: 	    tag += '</a>'
 1274: 	return tag
 1275: 
 1276:     
 1277:     security.declarePublic('getCreditObject')
 1278:     def getCreditObject(self,name):
 1279:         """credit id to credititem"""
 1280:         try:
 1281:             return getattr(self.partners,name)
 1282:         except:
 1283:             return ""
 1284: 
 1285:     security.declarePublic('ECHO_generateNavBar')
 1286:     def ECHO_generateNavBar(self):
 1287:         """Erzeuge Navigationsbar"""
 1288:         link=""
 1289:         object="self"
 1290:         ret=[]
 1291:         path=self.getPhysicalPath()
 1292:         for element in path:
 1293:             
 1294:            
 1295:             if not element=="":
 1296:                 object+="."+element
 1297:                 
 1298:                 label=eval(object).label
 1299:                 link+="/"+element
 1300:                 if not label=="":
 1301:                     ret.append((label,link))
 1302:         return ret
 1303:     
 1304:     security.declarePublic('ECHO_rerenderLinksMD')
 1305: 
 1306:     def ECHO_rerenderLinksMD(self,obj=None):
 1307:         """Rerender all Links"""
 1308:         if not obj:
 1309:             obj = self
 1310:             
 1311:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
 1312: 
 1313:         for entry in entries:
 1314: 		if entry[1].meta_type == 'ECHO_resource':
 1315: 			entry[1].ECHO_getResourceMD(template="no")
 1316: 
 1317: 		else:
 1318: 		   self.ECHO_rerenderLinksMD(entry[1])
 1319: 
 1320:                 
 1321:                 
 1322:         return "Rerenderd all links to resources in: "+self.title
 1323: 
 1324:     security.declarePublic('ECHO_newViewerLink')
 1325:     
 1326: 
 1327:     def getCoords(self):
 1328:         try:
 1329:             
 1330:             x=  [string.join(x,",") for x in self.coords]  
 1331:             return x
 1332: 
 1333:         except:
 1334: 
 1335:             return []
 1336:         
 1337:     def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):
 1338: 
 1339: 
 1340:         self.id = id
 1341:         """Festlegen der ID"""
 1342:         self.credits=toList(credits)
 1343:         self.label = label
 1344:         self.title=title
 1345:         self.description=description
 1346:         self.contentType=contentType
 1347:         self.responsible=responsible
 1348:         self.imageTag=imageTag
 1349:         self.weight=weight
 1350:         self.sortfield=sortfield
 1351:         coordsnew=[ string.split(x,",") for x in coords]
 1352:         self.coords=coordsnew
 1353:         self.secondaryLinkTitle=secondaryLinkTitle
 1354:         self.secondaryLink=secondaryLink
 1355: 	self.bgcolour=bgcolour
 1356:         
 1357: 
 1358:     manage_options = Folder.manage_options+(
 1359:         {'label':'Main Config','action':'ECHO_collection_config'},
 1360:         {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
 1361:         {'label':'Graphics','action':'ECHO_graphicEntry'},
 1362: 	{'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
 1363: 
 1364:         )
 1365: 
 1366:     def getOverview(self):
 1367:         """overview graphics"""
 1368:         
 1369:         return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
 1370:     
 1371:     
 1372:     def ECHO_graphicEntry(self):
 1373:         """DO nothing"""
 1374:         overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
 1375:         
 1376:     
 1377:         if overview:
 1378:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
 1379:             return pt()
 1380:         else:
 1381:             return "NO OVERVIEW GRAPHICS"
 1382: 
 1383:     def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
 1384:         """Enter coords"""
 1385:         coords=self.coords
 1386:         temco=coordstr.split(",")
 1387:         temco.append(angle)
 1388:         coords.append(temco)
 1389:         self.coords=coords[0:]
 1390: 
 1391:         if RESPONSE is not None:
 1392:             RESPONSE.redirect('ECHO_graphicEntry')
 1393: 
 1394:     
 1395:     security.declarePublic('ECHO_collection_config')
 1396:     def ECHO_collection_config(self):
 1397:         """Main configuration"""
 1398: 
 1399:         if not hasattr(self,'weight'):
 1400:             self.weight=""
 1401: 
 1402:         if not hasattr(self,'sortfield'):
 1403:             self.sortfield="weight"
 1404:   
 1405:         if not hasattr(self,'coords'):
 1406:             self.coords=[]
 1407: 
 1408:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_collection.zpt').__of__(self)
 1409:         return pt()
 1410: 
 1411: 
 1412:     security.declarePublic('changeECHO_collection')
 1413: 
 1414: 
 1415:     def getBgcolour(self):
 1416: 	    """colour"""
 1417: 	    if hasattr(self,'bgcolour') and not (self.bgcolour==""):
 1418: 		    return self.bgcolour
 1419: 	    else:
 1420: 		    return "#dddddd"
 1421: 	    
 1422:     def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",viewClassification=None):
 1423:         """Aenderung der Properties"""
 1424: 
 1425:         self.secondaryLink=secondaryLink
 1426:         self.secondaryLinkTitle=secondaryLinkTitle
 1427:         self.imageTag=imageTag
 1428: 	self.bgcolour=bgcolour
 1429:         self.viewClassification=viewClassification
 1430: 	
 1431:         if coords:
 1432:             coordsnew=[ string.split(x,",") for x in coords]
 1433:             self.coords=coordsnew[0:]
 1434:         else:
 1435:             coordsnew=None
 1436:             self.coords=None
 1437:             
 1438:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
 1439: 	try:
 1440: 		self.coords=coordsnew[0:] # HACK fehler in setECHO_collection
 1441:         except:
 1442: 		"""none"""
 1443: 		
 1444:         self.sortfield=sortfield
 1445: 
 1446:         if RESPONSE is not None:
 1447:             RESPONSE.redirect('manage_main')
 1448:             
 1449: 
 1450:     def showOverview(self):
 1451:         """overview"""
 1452:         if 'ECHO_overview.html' in self.__dict__.keys():
 1453:             return getattr(self,'ECHO_overview.html')()
 1454:         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)
 1455:         return pt()
 1456: 
 1457:     security.declareProtected('View','index_html')
 1458:     
 1459:     def index_html(self):
 1460:         """standard page"""
 1461:         
 1462:         if 'index.html' in self.__dict__.keys():
 1463:             return getattr(self,'index.html')()
 1464:         
 1465:         elif 'overview' in self.__dict__.keys():
 1466:             return self.showOverview()
 1467:         elif hasattr(self,'collection_index_template'):
 1468:             return self.collection_index_template()    
 1469:         elif hasattr(self,'main_index_template'):
 1470:             return self.main_index_template()    
 1471:         
 1472:         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
 1473:         pt.content_type="text/html"
 1474:         return pt()
 1475: 
 1476:     def content_html(self):
 1477:         """template fuer content"""
 1478:         return content_html(self,'collection')
 1479:     
 1480:     def getCredits(self):
 1481:         """Ausgabe der credits"""
 1482:         if self.credits:
 1483:             return self.credits
 1484:         else:
 1485:             return []
 1486: 
 1487:     def area_img(self):
 1488:         """area image"""
 1489: 	bt = BrowserCheck(self)
 1490: 	if bt.isIE or bt.isN4:
 1491: 	    return sendFile(self, 'images/red.gif', 'image/gif')
 1492: 	else:
 1493: 	    return sendFile(self, 'images/reda.png', 'image/png')
 1494: 
 1495:     def trans_img(self):
 1496:         """empty image"""
 1497:         return sendFile(self, 'images/trans.gif', 'image/gif')
 1498: 
 1499:     def hl_lib_js(self):
 1500:         """javascript"""
 1501:         return sendFile(self, 'js/hl_lib.js', 'text/plain')
 1502: 
 1503:     def js_lib_js(self):
 1504:         """javascript"""
 1505:         return sendFile(self, 'js/js_lib.js', 'text/plain')
 1506: 
 1507:     def getGraphicCoords(self):
 1508:         """Give list of coordinates"""
 1509:         subColTypes=['ECHO_collection','ECHO_resource']
 1510:         ids=[]
 1511:         for entrySearch in self.ZopeFind(self,obj_metatypes=subColTypes):
 1512:             object=entrySearch[1]
 1513:             if hasattr(object,'coords'):
 1514:                 for coordtemp in object.coords:
 1515:                     if len(coordtemp)>3:
 1516:                         coord=coordtemp[0:4]
 1517:                         label=""
 1518: 			vc=""
 1519:                         if hasattr(object,'label') and not object.label=="":
 1520:                             label=object.label
 1521:                         elif hasattr(object,'title') and not object.title=="":
 1522:                             label=object.title
 1523:                         else:
 1524:                             label=object.getId()
 1525: 			if object.viewClassification != "":
 1526: 			    vc=object.viewClassification
 1527: 			else:
 1528: 			    if len(coordtemp) > 4 and coordtemp[4] != "":
 1529: 				vc="view point"
 1530: 			    else:
 1531: 				vc="area"
 1532:                         ids.append([string.join(coord,", "),object.getId(),label,object,coordtemp,vc])
 1533:         return ids
 1534:     
 1535: 
 1536: 
 1537: 
 1538:     getSubCols = ECHO_helpers.getSubCols
 1539: 
 1540: Globals.InitializeClass(ECHO_collection)
 1541:     
 1542: def manage_addECHO_collectionForm(self):
 1543:         """Add collection form"""
 1544:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)
 1545:         return pt()
 1546: 
 1547: 
 1548: def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
 1549:     """add a echo collection"""
 1550:     
 1551: 
 1552:     newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
 1553: 
 1554:     self._setObject(id,newObj)
 1555: 
 1556:     if RESPONSE is not None:
 1557:         RESPONSE.redirect('manage_main')
 1558: 
 1559: class ECHO_group(ECHO_collection):
 1560: 	"""ECHO Gruppe"""
 1561: 	security=ClassSecurityInfo()
 1562: 	meta_type="ECHO_group"
 1563: 
 1564: 	manage_options = Folder.manage_options+(
 1565: 		{'label':'Main Config','action':'ECHO_group_config'},
 1566: 		{'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
 1567: 		{'label':'Graphics','action':'ECHO_graphicEntry'},
 1568: 		)
 1569: 	
 1570: 	security.declareProtected('View','index_html')
 1571: 	def index_html(self):
 1572: 		"""standard page"""
 1573: 		displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
 1574: 		#if (len(displayedObjects)==1) and (displayedObjects[0][1].meta_type=="ECHO_collection"): # nur ein Object dann redirect auf dieses Object
 1575: 		#	return self.REQUEST.RESPONSE.redirect(displayedObjects[0][1].absolute_url())
 1576: 		
 1577: 		if 'index.html' in self.__dict__.keys():
 1578: 			return getattr(self,'index.html')()
 1579: 		
 1580: 		elif 'overview' in self.__dict__.keys():
 1581: 			return self.showOverview()
 1582: 		elif hasattr(self,'group_index_template'):
 1583: 			return self.group_index_template()
 1584: 		elif hasattr(self,'collection_index_template'):
 1585: 			return self.collection_index_template()    
 1586: 		elif hasattr(self,'main_index_template'):
 1587: 		    return self.main_index_template()    
 1588: 
 1589: 		pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
 1590: 		pt.content_type="text/html"
 1591: 		return pt()
 1592: 
 1593: 	def ECHO_group_config(self):
 1594: 		"""Main configuration"""
 1595: 		
 1596: 		if not hasattr(self,'weight'):
 1597: 			self.weight=""
 1598: 			
 1599: 		if not hasattr(self,'sortfield'):
 1600: 			self.sortfield="weight"
 1601: 				
 1602: 		if not hasattr(self,'coords'):
 1603: 			self.coords=[]
 1604: 
 1605: 		pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)
 1606: 		return pt()
 1607: 
 1608: 	def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
 1609: 		"""Änderung der Properties"""
 1610: 
 1611: 		self.secondaryLink=secondaryLink
 1612: 		self.secondaryLinkTitle=secondaryLinkTitle
 1613: 		self.imageTag=imageTag
 1614: 		self.bgcolour=bgcolour
 1615:                 self.logo=logo
 1616:                 
 1617: 		if coords:
 1618: 		    coordsnew=[ string.split(x,",") for x in coords]
 1619: 		    self.coords=coordsnew[0:]
 1620: 		else:
 1621: 		    coordsnew=None
 1622: 		    self.coords=None
 1623: 
 1624: 		setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
 1625: 
 1626: 
 1627: 
 1628: 		self.sortfield=sortfield
 1629: 
 1630: 		if RESPONSE is not None:
 1631: 		    RESPONSE.redirect('manage_main')
 1632: 
 1633: 	def getLogo(self):    
 1634: 		"""logo ausgeben"""
 1635:                 try:
 1636:                     return self.logo
 1637:                 except:
 1638:                     return "ECHO_groups"
 1639: 
 1640: 	def content_html(self):
 1641: 		"""template fuer content"""
 1642: 		return content_html(self,'group')
 1643:     
 1644: 
 1645: 
 1646: def manage_addECHO_groupForm(self):
 1647:         """Add group form"""
 1648:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)
 1649:         return pt()
 1650: 
 1651: 
 1652: def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
 1653:     """add a echo group"""
 1654:     
 1655: 
 1656:     newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
 1657: 
 1658:     setattr(newObj,'logo',logo)
 1659:     self._setObject(id,newObj)
 1660:     
 1661:     if RESPONSE is not None:
 1662:         RESPONSE.redirect('manage_main')
 1663: 
 1664: Globals.InitializeClass(ECHO_group)
 1665: 
 1666: 
 1667: class ECHO_userFolder(UserFolder):
 1668: 	"""User folder for Intranet"""
 1669: 	_domain_auth_mode=1 # Identification via domain
 1670: 	meta_type="ECHO_userFolder"
 1671: 	
 1672: 	def authenticate(self, name, password, request):
 1673: 		emergency = self._emergency_user
 1674: 		if name is None:
 1675: 		    return None
 1676: 		if emergency and name==emergency.getUserName():
 1677: 		    user = emergency
 1678: 		else:
 1679: 		    user = self.getUser(name)
 1680: 		if user is not None and user.authenticate(password, request):
 1681: 		    return user
 1682: 		else:
 1683: 		    return None
 1684: 
 1685: 	def domainSpecMatch(self,spec, request):
 1686: 	    host=''
 1687: 	    addr=''
 1688: 
 1689: 	    # Fast exit for the match-all case
 1690: 	    if len(spec) == 1 and spec[0] == '*':
 1691: 		return 1
 1692: 
 1693: 	    if request.has_key('REMOTE_HOST'):
 1694: 		host=request['REMOTE_HOST']
 1695: 
 1696: 	    if request.has_key('REMOTE_ADDR'):
 1697: 		addr=request['REMOTE_ADDR']
 1698: 
 1699: 	    if request.has_key('HTTP_X_FORWARDED_FOR'):
 1700: 		addr=request['HTTP_X_FORWARDED_FOR']
 1701: 
 1702: 	    
 1703: 	    if not host and not addr:
 1704: 		return 0
 1705: 
 1706: 	    if not host:
 1707: 		try:    host=socket.gethostbyaddr(addr)[0]
 1708: 		except: pass
 1709: 	    if not addr:
 1710: 		try:    addr=socket.gethostbyname(host)
 1711: 		except: pass
 1712: 
 1713: 
 1714: 	    _host=host.split('.')
 1715: 	    _addr=addr.split('.')
 1716: 	    _hlen=len(_host)
 1717: 	    _alen=len(_addr)
 1718: 
 1719: 	    for ob in spec:
 1720: 		sz=len(ob)
 1721: 		_ob=ob.split('.')
 1722: 		_sz=len(_ob)
 1723: 
 1724: 		mo = addr_match(ob)
 1725: 		if mo is not None:
 1726: 		    if mo.end(0)==sz:
 1727: 			fail=0
 1728: 			for i in range(_sz):
 1729: 			    a=_addr[i]
 1730: 			    o=_ob[i]
 1731: 			    if (o != a) and (o != '*'):
 1732: 				fail=1
 1733: 				break
 1734: 			if fail:
 1735: 			    continue
 1736: 			return 1
 1737: 
 1738: 		mo = host_match(ob)
 1739: 		if mo is not None:
 1740: 		    if mo.end(0)==sz:
 1741: 			if _hlen < _sz:
 1742: 			    continue
 1743: 			elif _hlen > _sz:
 1744: 			    _item=_host[-_sz:]
 1745: 			else:
 1746: 			    _item=_host
 1747: 			fail=0
 1748: 			for i in range(_sz):
 1749: 			    h=_item[i]
 1750: 			    o=_ob[i]
 1751: 			    if (o != h) and (o != '*'):
 1752: 				fail=1
 1753: 				break
 1754: 			if fail:
 1755: 			    continue
 1756: 			return 1
 1757: 	    return 0
 1758: 
 1759: Globals.default__class_init__(ECHO_userFolder)
 1760: 
 1761: 
 1762: 
 1763: def manage_addECHO_userFolder(self,dtself=None,REQUEST=None,**ignored):
 1764:     """add a user folder """
 1765:     f=ECHO_userFolder()
 1766:     self=self.this()
 1767:     try:    self._setObject('acl_users', f)
 1768:     except: return MessageDialog(
 1769:                    title  ='Item Exists',
 1770:                    message='This object already contains a User Folder',
 1771:                    action ='%s/manage_main' % REQUEST['URL1'])
 1772:     self.__allow_groups__=f
 1773:     if REQUEST is not None:
 1774:         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
 1775: 
 1776: def manage_addECHO_userFolderForm(self):
 1777: 	"""add a user folder form"""
 1778: 	return manage_addECHO_userFolder(self)
 1779: 
 1780: class ECHO_root(Folder,Persistent,Implicit):
 1781:     """ECHO Root Folder"""
 1782: 
 1783:     security=ClassSecurityInfo()
 1784:     
 1785:     meta_type="ECHO_root"
 1786: 
 1787: 
 1788:     def getBibTag(self,tag,content):
 1789: 	    """get field tag für index-meta-generation"""
 1790: 	    if not content or content=="":
 1791: 		    return ""
 1792: 	    ret="<%s>"%tag
 1793: 	    ret+=urllib.quote(content)
 1794: 	    ret+="</%s>"%tag
 1795: 	    return ret
 1796: 
 1797:     def getValueFromClass(self,field,found):
 1798: 	    """retattribute falss existing"""
 1799: 	    try:
 1800: 		    return getattr(found,field)
 1801: 	    except:
 1802: 		    return ""
 1803:     
 1804:     def getImageTag(self):
 1805: 	    """needed by main_template"""
 1806: 	    return ""
 1807:     secondaryLink="" #needed by main_template
 1808:     secondaryLinkTitle="" #needed by main_template
 1809:     
 1810:     def getBgcolour(self):
 1811: 	"""hack"""
 1812: 	return "#dddddd"
 1813: 
 1814:     def contentTypeSelector_HTML(self,selected=None):
 1815:         """give type selector"""
 1816:         if not selected:
 1817:             retStr="<option selected>\n"
 1818:         else:
 1819:             retStr="<option>\n"
 1820:             
 1821:         try: # erste version contentTypes exists
 1822:             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):
 1823:                 if selected and (contentType[0]==selected):
 1824:                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
 1825:                 else:                
 1826:                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
 1827:         except:
 1828: 		try:
 1829: 			for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):
 1830: 				if selected and (contentType[0]==selected):
 1831: 					retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
 1832: 				else:                
 1833: 					retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
 1834: 		except:
 1835: 			"""nothing"""
 1836: 			    
 1837: 	return retStr
 1838: 
 1839:     def renderingTypeSelector_HTML(self,selected=None):
 1840:          """give type selector"""
 1841: 	 if not selected:
 1842: 		 retStr="<option selected>\n"
 1843: 	 else:
 1844: 		 retStr="<option>\n"
 1845: 		 
 1846: 	 try: # erste version renderingTypes exists
 1847: 		 for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
 1848: 			 if selected and (renderingType[0]==selected):
 1849: 				 retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
 1850: 			 else:                
 1851: 				 retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
 1852: 	 except:
 1853: 		 """nothing"""
 1854: 	 return retStr
 1855: 
 1856:     def renderingTypeSelector_HTML(self,selected=None):
 1857:          """give type selector"""
 1858: 	 if not selected:
 1859: 		 retStr="<option selected>\n"
 1860: 	 else:
 1861: 		 retStr="<option>\n"
 1862: 		 
 1863: 	 try: # erste version renderingTypes exists
 1864: 		 for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
 1865: 			 if selected and (renderingType[0]==selected):
 1866: 				 retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
 1867: 			 else:                
 1868: 				 retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
 1869: 	 except:
 1870: 		 """nothing"""
 1871: 	 return retStr
 1872: 
 1873: 
 1874:     def copyrightTypeSelector_HTML(self,selected=None):
 1875:          """give type selector"""
 1876: 	 if not selected:
 1877: 		 retStr="<option selected>\n"
 1878: 	 else:
 1879: 		 retStr="<option>\n"
 1880: 		 
 1881: 	 try: # erste version copyrightTypes exists
 1882: 		 for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
 1883: 			 if selected and (copyrightType[0]==selected):
 1884: 				 retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
 1885: 			 else:                
 1886: 				 retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
 1887: 	 except:
 1888: 		 """nothing"""
 1889: 	 return retStr
 1890: 
 1891:             
 1892:     def patchContentType(self,obj=None):
 1893:         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
 1894:     
 1895: 
 1896:         if not obj:
 1897:             obj = self
 1898:             
 1899:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
 1900: 
 1901:         for entry in entries:
 1902:                 setattr(entry[1],'contentType',entry[1].content_type)
 1903:                 #entry[1].contentType == entry[1].content_type
 1904: 
 1905:                 if entry[1].meta_type == 'ECHO_collection':
 1906:                     entry[1].patchContentType(entry[1])    
 1907: 
 1908:                 
 1909:         return "changed all contenttypes in: "+self.title
 1910: 
 1911: 
 1912:     def patchViewClassification(self,obj=None):
 1913:         """setze viewClassification heuristisch"""
 1914: 
 1915: 	def checkIfArrow(obj):
 1916: 		if hasattr(obj,'coords'):
 1917: 			for coordtemp in obj.coords:
 1918: 
 1919: 				if (len(coordtemp)>4) and not (coordtemp[4]==''):
 1920: 					return 4
 1921: 			return None
 1922: 		return None
 1923: 	
 1924:         if not obj:
 1925:             obj = self
 1926:             
 1927:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])
 1928: 
 1929:         for entry in entries:
 1930: 		
 1931: 		if checkIfArrow(entry[1]):
 1932: 			setattr(entry[1],'viewClassification','view point')
 1933: 		else:
 1934: 			setattr(entry[1],'viewClassification','area')
 1935: 
 1936:                 #entry[1].contentType == entry[1].content_type
 1937: 
 1938:                 if entry[1].meta_type in ['ECHO_collection','ECHO_group']:
 1939:                     entry[1].patchViewClassification(entry[1])    
 1940: 
 1941:                 
 1942:         return "changed all contenttypes in: "+self.title
 1943: 
 1944:     def ECHO_newViewerLink(self,obj=None):
 1945:         """change links (:86 faellt weg)"""
 1946: 
 1947:         if not obj:
 1948:             obj = self
 1949:             
 1950:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
 1951: 
 1952:         for entry in entries:
 1953:                 
 1954:                 if entry[1].meta_type == 'ECHO_resource':
 1955:                     
 1956:                     entry[1].link=re.sub('\:86','',entry[1].link)
 1957: 
 1958:                 else:
 1959:                     
 1960:                     entry[1].ECHO_newViewerLink(entry[1])
 1961:                 
 1962:         return "Rerenderd all links to resources in: "+self.title
 1963: 
 1964:     def __init__(self,id,title):
 1965:         """init"""
 1966:         self.id = id
 1967:         self.title=title
 1968: 
 1969:     def deleteSpace(self,str):
 1970:         """delete space at the end of a line"""
 1971:         if str[len(str)-1]==" ":
 1972:             return str[0:len(str)-1]
 1973:         else:
 1974:             return str
 1975:         
 1976:     
 1977: 
 1978:     # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
 1979: 
 1980:     def formatAscii(self,str,url=None):
 1981:         """ersetze ascii umbrueche durch <br>"""
 1982:         #url=None
 1983:         if url:
 1984:             
 1985:             retStr=""
 1986:             words=str.split("\n")
 1987:             
 1988:             for word in words:
 1989:                 strUrl=url%word
 1990: 
 1991:                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
 1992:             str=retStr
 1993:         if str:
 1994:             return re.sub(r"[\n]","<br/>",str)
 1995:         else:
 1996:             return ""
 1997:         
 1998:     def link2html(self,str):
 1999:         """link2html fuer VLP muss hier noch raus"""
 2000:         if str:
 2001: 
 2002:             str=re.sub("\&","&amp;",str)
 2003:             dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")
 2004:             links=dom.getElementsByTagName("link")
 2005:             
 2006: 
 2007:             for link in links:
 2008:                 link.tagName="a"
 2009:                 ref=link.getAttribute("ref")
 2010:                 if self.checkRef(ref):
 2011:                     link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
 2012: 
 2013:             return dom.toxml('utf-8')
 2014:         return ""
 2015: 
 2016: 
 2017:     def checkRef(self,ref):
 2018:         dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}
 2019:         res=None
 2020:         for db in dbs.keys():
 2021: 
 2022:             res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
 2023:         return res
 2024:                                     
 2025:     #Ende Methode fuer vlp
 2026: 
 2027:     def PgQuoteString(self,string):
 2028:         """Quote string"""
 2029: 
 2030:         return libpq.PgQuoteString(string)
 2031:         
 2032:     def getPartners(self):
 2033:         """Get list of Partners. Presently only from a subfolder partners"""
 2034:                     
 2035:         return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
 2036:                 
 2037:                 
 2038:                    
 2039: 
 2040:     
 2041:     def getPartnersXML(self):
 2042:         """partner liste als xml""" 
 2043:         partners=self.getPartners()
 2044:         ret="""<?xml version="1.0" encoding="utf-8" ?>
 2045: 	<partners>"""
 2046:         
 2047: 	for partner in partners:
 2048:             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),unicode(partner.title,'utf-8','replace'))
 2049: 
 2050:         return ret+"\n</partners>"
 2051:     
 2052:     def getCollectionTree(self):
 2053:         """get the collection tree (list of triples (parent,child, depth)"""
 2054: 
 2055:         def getCollection(object,depth=0):
 2056:             depth+=1
 2057:             collections=[]
 2058:             for entry in object.__dict__.keys():
 2059:                 element=getattr(object,entry)
 2060:                 try:
 2061:                     if element.meta_type=="ECHO_collection":
 2062:                         collections.append((object,element,depth))
 2063:                         collections+=getCollection(element,depth)
 2064:                 except:
 2065:                     """nothing"""
 2066:             return collections
 2067:         
 2068: 
 2069:         return getCollection(self)
 2070:     
 2071:     def getCollectionTreeIds(self):
 2072:         """Show the IDs of the Tree"""
 2073:         ret=[]
 2074:         for collection in self.getCollectionTree():
 2075:             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
 2076:         return ret
 2077: 
 2078:     def getResourcesHTML(self,viewerType=None,filter=None):
 2079: 	    """gebe all ressourcen aus"""
 2080: 
 2081: 	    def sortHTML(x,y):
 2082: 		    return cmp(x[1].title,y[1].title)
 2083: 	    
 2084: 	    ret="""<html><body><h2>Resources in ECHO</h3>"""
 2085: 	    
 2086: 	    resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
 2087: 	    ret+="""<h3>Found %i resources</h3>"""%len(resources)
 2088: 	    resources.sort(sortHTML)
 2089: 	    for resource in resources:
 2090: 		    echo_url=resource[1].absolute_url()
 2091: 		    
 2092: 		    if hasattr(resource[1],'title'):
 2093: 			    title=resource[1].title
 2094: 		    else:
 2095: 			    title="None"
 2096: 		    if filter:
 2097: 			    if re.search(filter,title):
 2098: 				    ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
 2099: 		    else:
 2100: 			    ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
 2101: 
 2102: 	    ret +="""\n</body></html>"""
 2103: 	    
 2104: 	    #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")
 2105: 	    #self.REQUEST.RESPONSE.write(ret)
 2106:     	    return ret
 2107:     
 2108:     def getResourcesXML(self,viewerType=None,filter=None):
 2109: 	    """gebe all ressourcen aus"""
 2110: 	    ret="""<?xml version="1.0" ?>
 2111: 	             <index>"""
 2112: 	    for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
 2113: 
 2114: 		    echo_url=resource[1].absolute_url()
 2115: 		    if hasattr(resource[1],'link'):
 2116: 			    viewer_url=resource[1].link
 2117: 		    else:
 2118: 			    viewer_url="NO URL"
 2119: 		    if filter:
 2120: 			    if re.search(filter,viewer_url):
 2121: 				    ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
 2122: 		    else:
 2123: 			    ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
 2124: 	    ret +="""\n</index>"""
 2125: 	    
 2126: 	    self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
 2127: 	    self.REQUEST.RESPONSE.write(ret)
 2128: 
 2129:     def getFullTextsXML(self,viewerType=None,filter=None):
 2130: 	    """gebe all ressourcen aus"""
 2131: 	    ret="""<?xml version="1.0" ?>
 2132: 	             <index>"""
 2133: 	    for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
 2134: 
 2135: 		    echo_url=resource[1].absolute_url()
 2136: 		    if resource[1].getFullTextXML(noredirect="yes"):
 2137: 			    if hasattr(resource[1],'link'):
 2138: 				    viewer_url=echo_url+"/getFullTextXML"
 2139: 			    else:
 2140: 				    viewer_url="NO URL"
 2141: 			    if filter:
 2142: 				    if re.search(filter,viewer_url):
 2143: 					    ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
 2144: 			    else:
 2145: 				    ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
 2146: 	    ret +="""\n</index>"""
 2147: 	    
 2148: 	    
 2149: 	    self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
 2150: 	    self.REQUEST.RESPONSE.write(ret)
 2151:         
 2152: def manage_addECHO_root(self,id,title,RESPONSE=None):
 2153:     """Add an ECHO_root"""
 2154:     self._setObject(id,ECHO_root(id,title))
 2155:     
 2156:     if RESPONSE is not None:
 2157:         RESPONSE.redirect('manage_main')
 2158: 
 2159: def manage_addECHO_rootForm(self):
 2160:         """Nothing yet"""
 2161:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)
 2162:         return pt()
 2163: 
 2164: class ECHO_copyrightType(Folder):
 2165: 	"""copyright typ"""
 2166: 
 2167: 	meta_type="ECHO_copyrightType"
 2168: 	
 2169: 	def __init__(self,id,title,label):
 2170: 		"""init"""
 2171: 		self.id=id
 2172: 		self.title=title
 2173: 		self.label=label
 2174: 
 2175: 	manage_options = Folder.manage_options+(
 2176:         {'label':'Main Config','action':'ECHO_copyrightType_config_mainForm'},
 2177: 	)
 2178: 
 2179: 	def ECHO_copyrightType_config_mainForm(self):
 2180: 		"""change form"""
 2181: 		pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_copyrightType').__of__(self)
 2182: 		pt.content_type="text/html"
 2183: 		return pt()
 2184: 
 2185: 	def ECHO_copyrightType_config_main(self,title,label,RESPONSE=None):
 2186: 		"""change"""
 2187: 		self.title=title
 2188: 		self.label=label
 2189: 
 2190: 		if RESPONSE is not None:
 2191: 			RESPONSE.redirect('manage_main')
 2192: 
 2193: def manage_addECHO_copyrightTypeForm(self):
 2194:         """Form for adding a ressource"""
 2195:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_copyrightTypeForm.zpt').__of__(self)
 2196:         return pt()
 2197: 
 2198: 
 2199: def manage_addECHO_copyrightType(self,id,title,label,RESPONSE=None):
 2200:     """addaresource"""
 2201: 
 2202:     newObj=ECHO_copyrightType(id,title,label)
 2203: 
 2204:     self._setObject(id,newObj)
 2205: 
 2206:     if RESPONSE is not None:
 2207:         RESPONSE.redirect('manage_main')
 2208:  
 2209: 
 2210:  
 2211: class ECHO_partner(Image,Persistent):
 2212:     """ECHO Partner"""
 2213: 
 2214:     meta_type="ECHO_partner"
 2215: 
 2216:     def __init__(self, id, title,url, file, content_type='', precondition=''):
 2217:         self.__name__=id
 2218:         self.title=title
 2219:         self.url=url
 2220:         self.precondition=precondition
 2221: 
 2222:         data, size = self._read_data(file)
 2223:         content_type=self._get_content_type(file, data, id, content_type)
 2224:         self.update_data(data, content_type, size)
 2225: 
 2226:     manage_options = Image.manage_options+(
 2227:         {'label':'Partner Information','action':'ECHO_partner_config'},
 2228:         )
 2229: 
 2230:     def changeECHO_partner(self,url,RESPONSE=None):
 2231:         """Change main information"""
 2232:         self.url=url
 2233:         if RESPONSE is not None:
 2234:             RESPONSE.redirect('manage_main')
 2235:             
 2236:             
 2237: 
 2238:     def ECHO_partner_config(self):
 2239:         """Main configuration"""
 2240:         if not hasattr(self,'url'):
 2241:             self.url=""
 2242:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_partner.zpt').__of__(self)
 2243:         return pt()
 2244: 
 2245:         
 2246: manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
 2247:                              Kind='ECHO_partner',kind='ECHO_partner')
 2248: 
 2249: 
 2250: 
 2251: def manage_addECHO_partner(self, id, file,url, title='', precondition='', content_type='',
 2252:                     REQUEST=None):
 2253:     """
 2254:     Add a new ECHO_partner object.
 2255: 
 2256:     Creates a new ECHO_partner object 'id' with the contents of 'file'.
 2257:     Based on Image.manage_addImage
 2258:     """
 2259: 
 2260:     id=str(id)
 2261:     title=str(title)
 2262:     content_type=str(content_type)
 2263:     precondition=str(precondition)
 2264: 
 2265:     id, title = OFS.Image.cookId(id, title, file)
 2266: 
 2267:     self=self.this()
 2268: 
 2269:     # First, we create the image without data:
 2270:     self._setObject(id, ECHO_partner(id,title,url,'',content_type, precondition))
 2271: 
 2272:     # Now we "upload" the data.  By doing this in two steps, we
 2273:     # can use a database trick to make the upload more efficient.
 2274:     if file:
 2275:         self._getOb(id).manage_upload(file)
 2276:     if content_type:
 2277:         self._getOb(id).content_type=content_type
 2278: 
 2279:     if REQUEST is not None:
 2280:         try:    url=self.DestinationURL()
 2281:         except: url=REQUEST['URL1']
 2282:         REQUEST.RESPONSE.redirect('%s/manage_main' % url)
 2283:     return id
 2284: 
 2285: