Return to ECHO_collection.py CVS log

Up to [Repository] / ECHO_content

chanceg file handling

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