Return to ECHO_collection.py CVS log

Up to [Repository] / ECHO_content

creastepdf added

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