Return to ECHO_collection.py CVS log

Up to [Repository] / ECHO_content

minor

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