File:  [Repository] / ECHO_content / ECHO_collection.py
Revision 1.222: download - view: text, annotated - select for diffs - revision graph
Wed Apr 13 15:13:19 2005 UTC (19 years, 2 months ago) by dwinter
Branches: MAIN
CVS tags: HEAD
http /rtsp adde

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

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