File:  [Repository] / ECHO_content / ECHO_collection.py
Revision 1.212: download - view: text, annotated - select for diffs - revision graph
Thu Feb 10 16:17:52 2005 UTC (19 years, 4 months ago) by dwinter
Branches: MAIN
CVS tags: HEAD
minor

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

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