Annotation of ECHO_content/ECHO_collection.py, revision 1.315

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

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