File:  [Repository] / ECHO_content / ECHO_collection.py
Revision 1.121: download - view: text, annotated - select for diffs - revision graph
Fri Jun 18 13:29:18 2004 UTC (19 years, 11 months ago) by jdamerow
Branches: MAIN
CVS tags: HEAD
getCopyrightsHTML()

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

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