Return to ECHO_collection.py CVS log

Up to [Repository] / ECHO_content

overview (red rectangles) now also uses ECHO_overview_main template in acquisition path

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