Return to ECHO_collection.py CVS log

Up to [Repository] / ECHO_content

minor

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