Annotation of ECHO_content/ECHO_root.py, revision 1.1.2.1

1.1.2.1 ! dwinter     1: """ECHO_root for the central functions for ECHO used by all objects
        !             2: 
        !             3: """
        !             4: 
        !             5:      
        !             6: import urlparse
        !             7: import string
        !             8: import tempfile
        !             9: import zipfile
        !            10: import re
        !            11: import os,shutil
        !            12: import OFS.Image
        !            13: from types import *
        !            14: from OFS.Cache import Cacheable
        !            15: from OFS.Image import Image
        !            16: from Globals import DTMLFile
        !            17: from OFS.Folder import Folder
        !            18: from OFS.SimpleItem import SimpleItem
        !            19: from AccessControl import ClassSecurityInfo
        !            20: from AccessControl.User import UserFolder
        !            21: from Globals import InitializeClass
        !            22: from Globals import DTMLFile
        !            23: import Globals
        !            24: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
        !            25: from Products.PageTemplates.PageTemplate import PageTemplate
        !            26: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate,manage_addPageTemplate
        !            27: from Globals import Persistent, package_home
        !            28: from Acquisition import Implicit
        !            29: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
        !            30: from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon
        !            31: import ECHO_helpers
        !            32: from Acquisition import aq_parent
        !            33: try:
        !            34:     from Products.MetaDataProvider.MetaDataClient import MetaDataClient
        !            35: except:
        !            36:     print "no metadataclient"
        !            37: import urllib
        !            38: import urllib2
        !            39: import cgi
        !            40: import smtplib
        !            41: import time
        !            42: #from Ft.Xml.Domlette import NonvalidatingReader
        !            43: #from Ft.Xml.Domlette import PrettyPrint, Print
        !            44: #from Ft.Xml import EMPTY_NAMESPACE
        !            45: #
        !            46: #import Ft.Xml.XPath
        !            47: import cStringIO
        !            48: 
        !            49: import sys
        !            50: import logging
        !            51: 
        !            52: try:
        !            53:         from psycopg import libpq
        !            54: except:
        !            55:         try:
        !            56:                 from pyPgSQL import libpq
        !            57:         except:
        !            58:                 print "ECHO_collection: Warning - No libpq imported!"
        !            59:                 
        !            60: import xml.dom.minidom
        !            61: 
        !            62: import urllib
        !            63: import xml.dom.minidom
        !            64: import ECHO_helpers
        !            65: from ECHO_helpers import *
        !            66: 
        !            67: 
        !            68: 
        !            69: #import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
        !            70: import xmlrpclib
        !            71: 
        !            72: import logging
        !            73: 
        !            74: #ersetzt logging.info
        !            75: def logger(txt,method,txt2):
        !            76:     """logging"""
        !            77:     logging.info(txt+ txt2)
        !            78: 
        !            79: 
        !            80: 
        !            81: 
        !            82: class ECHO_root(Folder,Persistent,Implicit):
        !            83:     """ECHO Root Folder"""
        !            84: 
        !            85:     security=ClassSecurityInfo()
        !            86:     
        !            87:     meta_type="ECHO_root"
        !            88:     management_page_charset="utf-8"
        !            89:     
        !            90:     getSubCols = ECHO_helpers.getSubCols
        !            91: 
        !            92:     manage_options=Folder.manage_options+(              
        !            93:                 {'label':'Main Config','action':'mainConfig_html'},
        !            94:                 {'label':'Change Weights','action':'changeWeights'},
        !            95:                 {'label':'Generate from RDF','action':'generateFromRDFForm'},
        !            96:                 {'label':'update Resource Catalog','action':'updateResourceCatalog'},
        !            97:                )
        !            98: 
        !            99: 
        !           100:     def mainConfig_html(self):
        !           101:         """change form"""
        !           102:         pt=zptFile(self, 'zpt/ChangeECHO_root.zpt')
        !           103:         pt.content_type="text/html"
        !           104:         return pt()
        !           105:   
        !           106:   
        !           107:     def getMetaDataManagerName(self):
        !           108:         """name of the metadatamanager"""
        !           109:         return getattr(self,"metaDataManagerName","metadata");
        !           110:         
        !           111:     
        !           112:     def changeECHO_root(self,metaDataManagerName,REQUEST=None):
        !           113:         """change the main properties"""
        !           114:         self.metaDataManagerName=metaDataManagerName
        !           115:         
        !           116:         if self.getMetaDataManager() is None:
        !           117:             return """"<html><body>ERROR: Folder: %s does not exist.
        !           118:             </body></html>
        !           119:             """%metaDataManagerName
        !           120:         
        !           121:         if REQUEST is not None:
        !           122:              REQUEST.RESPONSE.redirect('manage_main')
        !           123:         else:
        !           124:             return ""
        !           125:         
        !           126:         
        !           127:     def getMetaDataManager(self):
        !           128:          """hole eine Instanz von MetaDataFolder       
        !           129:          """
        !           130:     
        !           131:          mf= getattr(self,self.getMetaDataManagerName(),None)
        !           132:         
        !           133:          return mf
        !           134:          
        !           135: 
        !           136:     def getECHORootURL(self):
        !           137:         return self.absolute_url()
        !           138:     
        !           139:     def getECHORoot(self):
        !           140:         return self
        !           141: 
        !           142:     def getBrowserType(self):
        !           143:         """returns browserType object"""
        !           144:         return browserType(self)
        !           145:     
        !           146:     def mod_re_sub(self,pattern,replace,string):
        !           147:         """re.sub aus mod re zur Verfuegung stellen"""
        !           148:         return re.sub(pattern,replace,string)
        !           149:     
        !           150:     def findObjectFromFulltext(self,existUri):
        !           151:         '''
        !           152:         
        !           153:         @param url:
        !           154:         @param existUri:
        !           155:         '''
        !           156: 
        !           157:         if existUri:
        !           158:             #TODO: at the moment assume that the filename is unique, the whole has to changed to a system of ids.
        !           159:             filename=existUri.split("/")[-1]
        !           160:         
        !           161:         founds=self.resourceCatalog.search({'fullTextUrl':os.path.splitext(filename)[0]})  
        !           162:         
        !           163:         ret=[(found.title,found.getObject().absolute_url(),found.getObject().aq_parent.absolute_url()) for found in founds]
        !           164:         
        !           165:         return ret
        !           166:         
        !           167:     def reindex(self,RESPONSE=None):
        !           168:         """indiziere alle Objecte neu"""
        !           169:         
        !           170:         if RESPONSE:
        !           171:             RESPONSE.write("<html><body>")
        !           172:         
        !           173:         resources=self.ZopeFind(self,obj_metatypes=["ECHO_resource"], search_sub=1)
        !           174:         
        !           175:         for resource in resources:
        !           176:             resource[1].reindex()
        !           177:             #print "<p> done %s </p>\n"
        !           178:             if RESPONSE:
        !           179:                 RESPONSE.write("<p> done %s </p>\n"%resource[0])
        !           180:                 
        !           181:         if RESPONSE:
        !           182:             RESPONSE.write("<p> ok </p></html></body>\n")
        !           183:             
        !           184: 
        !           185:     def setLanguage(self,lang):
        !           186:             """Set language cookie"""
        !           187:             self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")
        !           188: 
        !           189:     def switchLanguage(self):
        !           190:             """Set language cookie"""
        !           191:             if self.getLanguage()=="en":
        !           192:                     lang="de"
        !           193:             else:
        !           194:                     lang="en"
        !           195:             
        !           196:             self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")
        !           197:             self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1'])
        !           198:             
        !           199:     def getLanguage(self):
        !           200:             """get language cookie"""
        !           201:             lang= self.REQUEST.cookies.get('lang_exhibition','de')
        !           202:             if lang == '':
        !           203:                     lang="de"
        !           204:             return lang
        !           205:     
        !           206:     def getContentOverviewTemplate(self):
        !           207:         """produces overview template with macro"""
        !           208:         pt = zptObjectOrFile(self, 'content_overview_template')
        !           209:         return pt
        !           210: 
        !           211:     def mapstyle_css(self):
        !           212:         """send mapstyle.css"""
        !           213:         sendFile(self, 'html/ECHO_mapstyle.css', 'text/css')
        !           214: 
        !           215: 
        !           216:     ###Cdli adds -> have to be removed
        !           217:     def getTablet(self,item):
        !           218:         #print "getTablet"
        !           219:         try:
        !           220:                 read=urllib.urlopen("http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"%item).read()
        !           221:                 read=re.sub("\[search\]","search",read)
        !           222:                 return read[read.find("<body>")+6:read.rfind("</body>")]
        !           223:         except:
        !           224:                 return "<h1>Sorry no connection to the data server enlil.museum.upenn.edu</h1>"
        !           225:         #return "http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"
        !           226:     ###END CDLI add
        !           227: 
        !           228: 
        !           229:     def URLquote(self, text):
        !           230:         """urllib.quote fuer Michael"""
        !           231:         return urllib.quote(text)
        !           232: 
        !           233: 
        !           234:     def checkResource(self,id):
        !           235:             """checks if a resource is in the tree, gives back none or list of resources"""
        !           236:             if not id:
        !           237:                 id=""
        !           238:             splitted=id.split("/")
        !           239:             id=splitted[len(splitted)-1]
        !           240:             if hasattr(self,"_v_checkResource") and self._v_checkResource.has_key(id): #existiert ein cache und id ist bereits drin?
        !           241:                             return self._v_checkResource[id]
        !           242: 
        !           243:             else:
        !           244:                     resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],obj_ids=[id],search_sub=1)
        !           245: 
        !           246:                     if not hasattr(self,"_v_checkResource"): self._v_checkResource={}#lege cache an falls nicht existent
        !           247:                     if resources:
        !           248:                             self._v_checkResource[id]=resources[0:] # slicing to be sure that data is stabil
        !           249:                     else:
        !           250:                             self._v_checkResource[id]=None
        !           251:                     
        !           252:                     return self._v_checkResource[id]
        !           253:             
        !           254:     def sendForm(self,fromaddr,content,server='mail.mpiwg-berlin.mpg.de'):
        !           255:             """sendform"""
        !           256:             toaddrs=["dwinter@mpiwg-berlin.mpg.de"]
        !           257:             
        !           258:             msg = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n"
        !           259:                    % (fromaddr, ", ".join(toaddrs),"testsub"))
        !           260:             server = smtplib.SMTP(server)
        !           261:             #server.set_debuglevel(1)
        !           262:             msg=msg+content
        !           263:             server.sendmail(fromaddr, toaddrs, msg)
        !           264:             server.quit()
        !           265:                  
        !           266:     def generateFromRDFForm(self):
        !           267:                 """change form"""
        !           268:                 pt=zptFile(self, 'zpt/generateFromRDFForm')
        !           269:                 pt.content_type="text/html"
        !           270:                 return pt()
        !           271: 
        !           272:     def generateFromRDF(self,file,startNode="/Cuneiform Corpus"):
        !           273: 
        !           274:             """generate from RDF"""
        !           275: 
        !           276:             global seqs
        !           277:             seqs={}
        !           278:             global descrs
        !           279:             descrs={}
        !           280:             global key
        !           281:             key=""
        !           282:             global value
        !           283:             value=""
        !           284: 
        !           285:             def getEdges(seqs,urn):
        !           286:                     """edges"""
        !           287:                     ret=[]
        !           288:                     return seqs[urn]
        !           289: 
        !           290:             def createSubs(self,seqs,descrs,urn,level=0):
        !           291:                     """create subs"""
        !           292:                     for edge in getEdges(seqs,urn):
        !           293:                             cn=createNode(self,descrs,edge)
        !           294:                             if cn[0]=="CDLI_group":
        !           295:                                     createSubs(cn[1],seqs,descrs,cn[2],level+1)
        !           296:                     return
        !           297: 
        !           298:             def start_element(name,attrs):
        !           299: 
        !           300:                     global seqs
        !           301:                     global descrs
        !           302:                     global key
        !           303:                     global value
        !           304:                     seq=""
        !           305:                     if name=="rdf:Seq":
        !           306:                             key=attrs.get('rdf:about')
        !           307:                             try: # teste ob liste
        !           308:                                     x=seqs[key][0]
        !           309:                             except:
        !           310: 
        !           311:                                     seqs[key]=[]
        !           312: 
        !           313:                     
        !           314:                     elif name=="rdf:Description":
        !           315:                             key=attrs.get('rdf:about')
        !           316:                             
        !           317: 
        !           318:                     elif name=="rdf:li":
        !           319:                             name=attrs.get('rdf:resource')
        !           320:                             seqs[key].append(name)
        !           321: 
        !           322:                     elif name=="echonavigation:type":
        !           323:                             value="type"
        !           324: 
        !           325:                     elif name=="echonavigation:name":
        !           326:                             value="name"
        !           327:                     elif name=="echonavigation:linkClickable":
        !           328:                             value="linkClickable"
        !           329:                             
        !           330:             def end_element(name):
        !           331:                             """nothing"""
        !           332:                             key=""
        !           333:                             value=""
        !           334: 
        !           335:             def char_data(data):
        !           336:                     """nothing"""
        !           337: 
        !           338:                     data=re.sub("\n","",data)
        !           339:                     try:
        !           340:                             if descrs[key].has_key(value):
        !           341:                                     descrs[key][value]+=data
        !           342:                             else:
        !           343:                                     descrs[key][value]=data
        !           344:                     except:
        !           345: 
        !           346:                             descrs[key]={}
        !           347:                             descrs[key][value]=data
        !           348:                             
        !           349:             p = xml.parsers.expat.ParserCreate()
        !           350:             
        !           351:             p.StartElementHandler = start_element
        !           352:             p.EndElementHandler = end_element
        !           353:             p.CharacterDataHandler = char_data
        !           354:             
        !           355:             
        !           356:             p.ParseFile(file)
        !           357:             self.REQUEST.RESPONSE.write("<html><body><h1>Start</h1>")
        !           358:             createSubs(self,seqs,descrs,startNode)
        !           359:             self.REQUEST.RESPONSE.write("<h1>done</h1></body></html>")
        !           360:             #print "done"
        !           361: 
        !           362:             
        !           363:             return "done"
        !           364:     
        !           365:             
        !           366: 
        !           367:                 
        !           368:     def changeWeightsInCollection(self):
        !           369:             """change all lables of a collection"""
        !           370:             ret=""
        !           371:             argv=self.REQUEST.form
        !           372:             
        !           373:             resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
        !           374:             for resource in resources:
        !           375:                    
        !           376:                     try:
        !           377:                             ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
        !           378:                             resource[1].weight=argv[resource[1].getId()][0:]
        !           379:                     except:
        !           380:                             pass
        !           381:             return ret
        !           382: 
        !           383:     def changeWeights(self):
        !           384:                 """change form"""
        !           385:                 pt=zptFile(self, 'zpt/changeWeightForm')
        !           386:                 pt.content_type="text/html"
        !           387:                 return pt()
        !           388:   
        !           389:     
        !           390:     def getRDF(self,urn=None):
        !           391:             """rdf of the collection"""
        !           392: 
        !           393:             contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
        !           394: 
        !           395:             ret=getRDFDescription(self,self.absolute_url(),urn=urn)
        !           396:             
        !           397:             li="""<rdf:li rdf:resource="%s" />\n"""
        !           398: 
        !           399:             
        !           400:             for content in contents:
        !           401:                     ret+=content[1].getRDF()+"\n"
        !           402:                     
        !           403:             ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
        !           404:             for content in contents:
        !           405:                     nurn=content[1].absolute_url()
        !           406:                     ret+=li%nurn
        !           407:             return ret+"</rdf:Seq>"
        !           408:             
        !           409: 
        !           410:     def showContent(self,path):
        !           411:             """return content/html"""
        !           412:             
        !           413:             return ECHO_helpers.urlopen(path+"/content_html").read()
        !           414:     
        !           415:     
        !           416: 
        !           417:     def getBibTag(self,tag,content):
        !           418:             """get field tag for index-meta-generation"""
        !           419:             if not content or content=="":
        !           420:                     return ""
        !           421:             ret="<%s>"%tag
        !           422:             #ret+=urllib.quote(content)
        !           423:             ret+=content
        !           424: 
        !           425:             ret+="</%s>"%tag
        !           426:             return ret
        !           427: 
        !           428:     def getValueFromClass(self,field,found):
        !           429:             """ret attribute if existing"""
        !           430:             try:
        !           431:                     
        !           432: 
        !           433:                     return getattr(found,field)#.decode('ascii','ignore')
        !           434: 
        !           435: 
        !           436: 
        !           437:             except:
        !           438:                     logging.error("can't: decode: %s"%repr(field))
        !           439:                     logging.error("      %s %s"%(sys.exc_info()[0],sys.exc_info()[1]))
        !           440:                     return ""
        !           441: 
        !           442:     security.declarePublic('getImageTag')
        !           443:     def getImageTag(self):
        !           444:             """needed by main_template"""
        !           445:             return ""
        !           446:         
        !           447:     secondaryLink="" #needed by main_template
        !           448:     secondaryLinkTitle="" #needed by main_template
        !           449:     
        !           450:     def getBgcolour(self):
        !           451:         """hack"""
        !           452:         return "#dddddd"
        !           453: 
        !           454:     security.declareProtected('View','contentTypeSelector_HTML')
        !           455:     def contentTypeSelector_HTML(self,selected=None):
        !           456:         """give type selector"""
        !           457:         if not selected:
        !           458:             retStr="<option selected>\n"
        !           459:         else:
        !           460:             retStr="<option>\n"
        !           461:             
        !           462:         try: # erste version contentTypes exists
        !           463:             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType"]):
        !           464:                 if selected and (contentType[0]==selected):
        !           465:                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
        !           466:                 else:                
        !           467:                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
        !           468:         except:
        !           469:                 
        !           470:                 """nothing"""
        !           471:                             
        !           472:         return retStr
        !           473: 
        !           474:     def renderingTypeSelector_HTML(self,selected=None):
        !           475:          """give type selector"""
        !           476:          if not selected:
        !           477:                  retStr="<option selected>\n"
        !           478:          else:
        !           479:                  retStr="<option>\n"
        !           480:                  
        !           481:          try: # erste version renderingTypes exists
        !           482:                  for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
        !           483:                          if selected and (renderingType[0]==selected):
        !           484:                                  retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
        !           485:                          else:                
        !           486:                                  retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
        !           487:          except:
        !           488:                  """nothing"""
        !           489:          return retStr
        !           490: 
        !           491: 
        !           492:     def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):
        !           493:          """give type selector"""
        !           494: 
        !           495:          if not first:
        !           496:                  if not selected:
        !           497:                          retStr="<option selected>\n"
        !           498:                  else:
        !           499:                          retStr="<option>\n"
        !           500:          else:
        !           501:                  if not selected:
        !           502:                          retStr="""<option selected value="%s">%s\n"""%first
        !           503:                  else:
        !           504:                          retStr="""<option value="%s">%s\n"""%first
        !           505: 
        !           506:          
        !           507:          try: # erste version copyrightTypes exists
        !           508:                  for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
        !           509:                          if selected and (copyrightType[0]==selected):
        !           510:                                  retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
        !           511:                          else:                
        !           512:                                  retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
        !           513:                  
        !           514:                  for copyrightTypeSelf in self.ZopeFind(object,obj_metatypes=["ECHO_copyrightType"],search_sub=1):
        !           515:                          if selected and (copyrightTypeSelf[0]==selected):
        !           516:                                  retStr+="""<option selected value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
        !           517:                          else:                
        !           518:                                  retStr+="""<option value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
        !           519:                                  
        !           520:          except:
        !           521:              """nothing"""
        !           522:                  
        !           523:          return retStr
        !           524: 
        !           525:     def partnerSelector_HTML(self,selected=None):
        !           526:          """give type selector"""
        !           527:          if not selected:
        !           528:                  retStr="<option selected>\n"
        !           529:          else:
        !           530:                  retStr="<option>\n"
        !           531:                  
        !           532:          try: # erste version copyrightTypes exists
        !           533:                  for copyrightType in self.ZopeFind(self.partners,obj_metatypes=["ECHO_partner"]):
        !           534:                          if selected and (copyrightType[0]==selected):
        !           535:                                  retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
        !           536:                          else:                
        !           537:                                  retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
        !           538:          except:
        !           539:                  """nothing"""
        !           540:          return retStr
        !           541:  
        !           542:     mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version ueber echoroot??
        !           543: 
        !           544:     def mediaTypeSelector_HTML(self,selected=None):
        !           545:          """give type selector"""
        !           546:          if not selected:
        !           547:                  retStr="<option selected>\n"
        !           548:          else:
        !           549:                  retStr="<option>\n"
        !           550:          
        !           551:          try: # erste version mediatypesTypes exists
        !           552:                  for mediaType in self.mediaTypes:
        !           553:                          if selected and (mediaType in selected):
        !           554:                                  retStr+="""<option selected value="%s">%s\n"""%(mediaType,mediaType)
        !           555:                          else:                
        !           556:                                  retStr+="""<option value="%s">%s\n"""%(mediaType,mediaType)
        !           557:          except:
        !           558:                  """nothing"""
        !           559:          return retStr
        !           560: 
        !           561:             
        !           562:     def patchContentType(self,obj=None):
        !           563:         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
        !           564:     
        !           565: 
        !           566:         if not obj:
        !           567:             obj = self
        !           568:             
        !           569:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
        !           570: 
        !           571:         for entry in entries:
        !           572:                 setattr(entry[1],'contentType',entry[1].content_type)
        !           573:                 #entry[1].contentType == entry[1].content_type
        !           574: 
        !           575:                 if entry[1].meta_type == 'ECHO_collection':
        !           576:                     entry[1].patchContentType(entry[1])    
        !           577: 
        !           578:                 
        !           579:         return "changed all contenttypes in: "+self.title
        !           580: 
        !           581: 
        !           582:     def repairAllCoords(self):
        !           583:         """updates map coordinates on the same and sublevels"""
        !           584:         return repairCoords(self)
        !           585: 
        !           586: 
        !           587:     def patchViewClassification(self,obj=None):
        !           588:         """setze viewClassification heuristisch"""
        !           589: 
        !           590:         def checkIfArrow(obj):
        !           591:                 if hasattr(obj,'coords'):
        !           592:                         for coordtemp in obj.coords:
        !           593: 
        !           594:                                 if (len(coordtemp)>4) and not (coordtemp[4]==''):
        !           595:                                         return 4
        !           596:                         return None
        !           597:                 return None
        !           598:         
        !           599:         if not obj:
        !           600:             obj = self
        !           601:             
        !           602:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])
        !           603: 
        !           604:         for entry in entries:
        !           605:                 
        !           606:                 if checkIfArrow(entry[1]):
        !           607:                         setattr(entry[1],'viewClassification','view point')
        !           608:                 else:
        !           609:                         setattr(entry[1],'viewClassification','area')
        !           610: 
        !           611:                 #entry[1].contentType == entry[1].content_type
        !           612: 
        !           613:                 if entry[1].meta_type in ['ECHO_collection','ECHO_group']:
        !           614:                     entry[1].patchViewClassification(entry[1])    
        !           615: 
        !           616:                 
        !           617:         return "changed all contenttypes in: "+self.title
        !           618: 
        !           619:     def deleteCache(self,obj=None,RESPONSE=None):
        !           620:         """setze alle collections auf cache = CacheManager"""
        !           621:         if not obj:
        !           622:             obj = self
        !           623:         entries=obj.ZopeFind(obj,search_sub=1)
        !           624:         for entry in entries:
        !           625:                 if hasattr(entry[1],'_v_hash'):
        !           626:                         entry[1]._v_hash=None
        !           627:         
        !           628:         return "changed all CM in: "+self.title
        !           629: 
        !           630:     
        !           631:     security.declarePublic('ECHO_newViewerLink')
        !           632:     def ECHO_newViewerLink(self,obj=None):
        !           633:         """change links (:86 faellt weg)"""
        !           634: 
        !           635:         if not obj:
        !           636:             obj = self
        !           637:             
        !           638:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
        !           639: 
        !           640:         for entry in entries:
        !           641:                 
        !           642:                 if entry[1].meta_type == 'ECHO_resource':
        !           643:                     
        !           644:                     entry[1].link=re.sub('\:86','',entry[1].link)
        !           645: 
        !           646:                 else:
        !           647:                     
        !           648:                     entry[1].ECHO_newViewerLink(entry[1])
        !           649:                 
        !           650:         return "Rerenderd all links to resources in: "+self.title
        !           651: 
        !           652:     def __init__(self,id,title):
        !           653:         """init"""
        !           654:         self.id = id
        !           655:         self.title=title
        !           656: 
        !           657:     def deleteSpace(self,str):
        !           658:         """delete space at the end of a line"""
        !           659:         if str[len(str)-1]==" ":
        !           660:             return str[0:len(str)-1]
        !           661:         else:
        !           662:             return str
        !           663:         
        !           664:     
        !           665: 
        !           666:     # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
        !           667: 
        !           668:     def formatAscii(self,str,url=None):
        !           669:         """ersetze ascii umbrueche durch <br>"""
        !           670: 
        !           671:         if not str: 
        !           672:                 return ""
        !           673:     
        !           674:         if url:
        !           675:             
        !           676:             retStr=""
        !           677:             words=str.split("\n")
        !           678:             
        !           679:             for word in words:
        !           680:                 strUrl=url%word
        !           681:     
        !           682:                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
        !           683:             str=retStr
        !           684:         if str:
        !           685:             str = re.sub(r"[\n]","<br/>",str)
        !           686:             return unicodify(str)
        !           687:         else:
        !           688:             return u""
        !           689:             
        !           690:     #link2html=vlp_xmlhelpers.link2html
        !           691:     #related2html=vlp_xmlhelpers.related2html
        !           692: 
        !           693:     #xml2html=vlp_xmlhelpers.xml2html
        !           694:  
        !           695:     #checkRef=vlp_xmlhelpers.checkRef
        !           696:     
        !           697: #    def checkRef(self,ref):
        !           698: #            if ref[0:3]=='lit':
        !           699: #                    if len(self.library_data({ 'id':ref}))>0:
        !           700: #                            return 1
        !           701: #            try:
        !           702: #                    if ref[0:7]=="tec_cat":
        !           703: #                            return 1
        !           704: #            except:
        !           705: #                    """nothing"""
        !           706: #                    
        !           707: #            dbs={'vl_technology':'','vl_people':" AND complete='yes'",'vl_sites':''}
        !           708: #            res=None
        !           709: #            for db in dbs.keys():
        !           710: #                    res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
        !           711: #            return res
        !           712: #                                    
        !           713: #    #Ende Methode fuer vlp
        !           714: 
        !           715:     def PgQuoteString(self,string):
        !           716:         """Quote string"""
        !           717: 
        !           718:         return libpq.PgQuoteString(string)
        !           719: 
        !           720:     security.declareProtected('View','getPartners')
        !           721:     def getPartners(self):
        !           722:         """Get list of Partners. Presently only from a subfolder partners"""
        !           723:         if hasattr(self,'partners'):            
        !           724:                 ret = [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
        !           725:                 def sort_title(one, another) : return cmp(one.title, another.title)
        !           726:                 ret.sort(sort_title)
        !           727:                 return ret
        !           728:         else:
        !           729:                 return []
        !           730:   
        !           731:     def getInstitutions(self):
        !           732:         """Get list of Partners. Presently only from a subfolder partners"""
        !           733:                     
        !           734:         return [ item[1] for item in self.institutions.ZopeFind(self.institutions,obj_metatypes=['ECHO_institution'])]
        !           735: 
        !           736:    
        !           737:     def getPartnersXML(self):
        !           738:         """partner liste als xml""" 
        !           739:         partners=self.getPartners()
        !           740:         ret="""<?xml version="1.0" encoding="utf-8" ?>
        !           741:         <partners>"""
        !           742:         
        !           743:         for partner in partners:
        !           744:             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)
        !           745: 
        !           746:         return ret+"\n</partners>"
        !           747:     
        !           748:     def getCollectionTree(self):
        !           749:         """get the collection tree (list of triples (parent,child, depth)"""
        !           750: 
        !           751:         def getCollection(object,depth=0):
        !           752:             depth+=1
        !           753:             collections=[]
        !           754:             for entry in object.__dict__.keys():
        !           755:                 element=getattr(object,entry)
        !           756:                 try:
        !           757:                     if element.meta_type=="ECHO_collection":
        !           758:                         collections.append((object,element,depth))
        !           759:                         collections+=getCollection(element,depth)
        !           760:                 except:
        !           761:                     """nothing"""
        !           762:             return collections
        !           763:         
        !           764: 
        !           765:         return getCollection(self)
        !           766:     
        !           767:     def getCollectionTreeIds(self):
        !           768:         """Show the IDs of the Tree"""
        !           769:         ret=[]
        !           770:         for collection in self.getCollectionTree():
        !           771:             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
        !           772:         return ret
        !           773: 
        !           774:     def getResourcesHTML(self,viewerType=None,filter=None):
        !           775:             """gebe all ressourcen aus"""
        !           776: 
        !           777:             def sortHTML(x,y):
        !           778:                     return cmp(x[1].title,y[1].title)
        !           779:             
        !           780:             ret="""<html><body><h2>Resources in ECHO</h3>"""
        !           781:             
        !           782:             resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource','VLP_resource'],search_sub=1)
        !           783:             ret+="""<h3>Found %i resources</h3>"""%len(resources)
        !           784:             resources.sort(sortHTML)
        !           785:             for resource in resources:
        !           786:                     echo_url=resource[1].absolute_url()
        !           787:                     
        !           788:                     if hasattr(resource[1],'title'):
        !           789:                             title=resource[1].title
        !           790:                     else:
        !           791:                             title="None"
        !           792:                     if filter:
        !           793:                             if re.search(filter,title):
        !           794:                                     ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
        !           795:                     else:
        !           796:                             ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
        !           797: 
        !           798:             ret +="""\n</body></html>"""
        !           799:             
        !           800:             #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")
        !           801:             #self.REQUEST.RESPONSE.write(ret)
        !           802:             return ret
        !           803:     
        !           804:     def getResourcesXML(self,viewerType=None,filter=None):
        !           805:             """gebe all ressourcen aus"""
        !           806:             ret="""<?xml version="1.0" ?>
        !           807:                      <index>"""
        !           808:             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource','VLP_resource'],search_sub=1):
        !           809: 
        !           810:                     echo_url=resource[1].absolute_url()
        !           811:                     if hasattr(resource[1],'link'):
        !           812:                             viewer_url=resource[1].link
        !           813:                     else:
        !           814:                             viewer_url="NO URL"
        !           815:                     if filter:
        !           816:                             if re.search(filter,viewer_url):
        !           817:                                     ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
        !           818:                     else:
        !           819:                             ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
        !           820:             ret +="""\n</index>"""
        !           821:             
        !           822:             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
        !           823:             self.REQUEST.RESPONSE.write(ret)
        !           824: 
        !           825:     def getCollectionsXML(self,viewerType=None,filter=None):
        !           826:             """gebe collections aus"""
        !           827:             ret="""<?xml version="1.0" ?>
        !           828:                      <index>"""
        !           829:             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_collection','ECHO_group'],search_sub=1):
        !           830: 
        !           831:                     echo_url=resource[1].absolute_url()
        !           832:                  
        !           833:                     ret+="""\n<collection echoLink="%s"/>"""%urllib.quote(echo_url,safe='/:?')
        !           834:             ret +="""\n</index>"""
        !           835:             
        !           836:             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
        !           837:             self.REQUEST.RESPONSE.write(ret)
        !           838: 
        !           839:     def getFullTextsXML(self,viewerType=None,filter=None):
        !           840:             """gebe all ressourcen aus"""
        !           841:             ret="""<?xml version="1.0" ?>
        !           842:                      <index>"""
        !           843:             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
        !           844: 
        !           845:                     echo_url=resource[1].absolute_url()
        !           846:                     if resource[1].getFullTextXML(noredirect="yes"):
        !           847:                             if hasattr(resource[1],'link'):
        !           848:                                     viewer_url=echo_url+"/getFullTextXML"
        !           849:                             else:
        !           850:                                     viewer_url="NO URL"
        !           851:                             if filter:
        !           852:                                     if re.search(filter,viewer_url):
        !           853:                                             ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
        !           854:                             else:
        !           855:                                     ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
        !           856:             ret +="""\n</index>"""
        !           857:             
        !           858:             
        !           859:             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
        !           860:             self.REQUEST.RESPONSE.write(ret)
        !           861: 
        !           862: 
        !           863:     def getMetaDatasXML(self,viewerType=None,filter=None):
        !           864:             """gebe all ressourcen aus"""
        !           865:             # check if the request's host part was OK
        !           866:             http_host = self.REQUEST['HTTP_HOST']
        !           867:             host_port = self.REQUEST['SERVER_PORT']
        !           868:             fix_host = None
        !           869:             if http_host and http_host.rfind(host_port) == -1:
        !           870:                     print "HTTP_HOST needs fixing!"
        !           871:                     fix_host = http_host + ":" + host_port
        !           872: 
        !           873:             ret="""<?xml version="1.0" ?>
        !           874:                      <index>"""
        !           875:             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
        !           876: 
        !           877:                     echo_url=resource[1].absolute_url()
        !           878:                     if fix_host:
        !           879:                             #print "replacing ", http_host, " by ", fix_host
        !           880:                             echo_url = string.replace(echo_url, http_host, fix_host, 1)
        !           881:                     
        !           882:                     if hasattr(resource[1],'link'):
        !           883:                             meta_url=echo_url+"/getMetaDataXML"
        !           884:                     else:
        !           885:                             meta_url="NO_URL"
        !           886:                             
        !           887:                     if filter and not re.search(filter,viewer_url):
        !           888:                             continue
        !           889: 
        !           890:                     #modificationDate=time.strptime(str(resource[1].bobobase_modification_time()),"%Y/%m/%d %H:%M:%S %Z")
        !           891:                     
        !           892:                     modificationDate=resource[1].bobobase_modification_time().strftime("%Y/%m/%d %H:%M:%S")
        !           893: 
        !           894:                     ret+="""\n<resource resourceLink="%s" metaLink="%s" modificationDate="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(meta_url,safe='/:?'),modificationDate)
        !           895:                     
        !           896:                             
        !           897:             ret +="""\n</index>"""
        !           898: 
        !           899:             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
        !           900:             self.REQUEST.RESPONSE.write(ret)
        !           901: 
        !           902:             
        !           903:     def findPartners(self):     
        !           904:         """find all partners in partners"""
        !           905:         par=self.ZopeFind(self.partners, obj_metatypes='ECHO_partner')
        !           906:         return par
        !           907:         
        !           908:     def getPartnerFromID(self):
        !           909:         """find partner form ID return object"""
        !           910:         pa=self.REQUEST['partner']
        !           911:         par=self.ZopeFind(self.partners, obj_ids=[pa])
        !           912:         return par
        !           913:         
        !           914:     def getPartnerFromIDParameter(self, id):
        !           915:         """ find partners from ID"""
        !           916:         par=self.ZopeFind(self.partners, obj_ids=[id])
        !           917:         return par
        !           918:         
        !           919:     def getInstitutionFromID(self,id):
        !           920:         """ find institution from id """
        !           921:         inst=self.ZopeFind(self.institutions, obj_ids=[id])
        !           922:         return inst
        !           923: 
        !           924:     def updateResourceCatalog(self,REQUEST,RESPONSE):
        !           925:         """update ressource catalog"""
        !           926:         catalog=getattr(self,'resourceCatalog',None)
        !           927:         if not catalog:
        !           928:             return """<html><body><h3>No resourceCatalog available</h3></body></html>"""
        !           929:         
        !           930:         else:
        !           931:             class element:
        !           932:                 def __init__(self,group,name):
        !           933:                     self.group=group
        !           934:                     self.name=name
        !           935:             catalog.manage_delObjects('author splitter')
        !           936:             #elements=[element('Stop Words',""" Don't remove stop words' """),element('Word Splitter','ECHO author splitter')]
        !           937:             elements=[element('Word Splitter','ECHO author splitter')]
        !           938:             manage_addLexicon(catalog,id="author splitter",elements=elements)
        !           939:             
        !           940:             return catalog.manage_catalogReindex(REQUEST,RESPONSE,'manage_main')
        !           941:             
        !           942:         
        !           943:     def checkMetaDataLinks(self,correct=None):
        !           944:         """check all metadatalinks and if correct is set change the servername to content.mpiwg-berlin.mpg.de"""
        !           945:         
        !           946:         self.REQUEST.RESPONSE.write("<html><body>")
        !           947:         for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
        !           948:             metalink=resource[1].metalink
        !           949:         
        !           950:             try:
        !           951:                 url=urllib.urlopen(metalink)
        !           952:             except:
        !           953:                 
        !           954:                 self.REQUEST.RESPONSE.write("<p>ERROR (opening %s):"%resource[1].absolute_url() +" -- %s %s <br>"%sys.exc_info()[0:2])
        !           955:                 self.REQUEST.RESPONSE.write("-----------%s"%metalink)
        !           956:             
        !           957:                 if correct:
        !           958:                     urlparsed=[x for x in urlparse.urlparse(metalink)]
        !           959:                     urlparsed[1]="content.mpiwg-berlin.mpg.de"
        !           960:                     neu=urlparse.urlunparse(urlparsed)
        !           961:                     resource[1].metalink=neu[0:]
        !           962:                     self.REQUEST.RESPONSE.write("----------changed to:%s)"%neu)
        !           963:    
        !           964:    
        !           965:    
        !           966: def manage_addECHO_root(self,id,title,RESPONSE=None):
        !           967:     """Add an ECHO_root"""
        !           968:     self._setObject(id,ECHO_root(id,title))
        !           969:     
        !           970:     if RESPONSE is not None:
        !           971:         RESPONSE.redirect('manage_main')
        !           972: 
        !           973: def manage_addECHO_rootForm(self):
        !           974:         """Nothing yet"""
        !           975:         pt=zptFile(self, 'zpt/AddECHO_root.zpt')
        !           976:         return pt()
        !           977:     
        !           978:     
        !           979:     
        !           980: from ECHO_Nav import ECHO_navigation
        !           981: 
        !           982: class ECHO_main(ECHO_root,ECHO_navigation):
        !           983:     """echo main object combines ECHO_root and ECHO_navigation"""
        !           984:     
        !           985:     meta_type="ECHO_main"
        !           986:     
        !           987:     def __init__(self,id,title):
        !           988:         """init"""
        !           989:         self.id=id
        !           990:         self.title=title
        !           991:         self.pathToHierarchy="/"+self.id # hierarchie always starts with the object.
        !           992:         self.displayedMetaTypes=displayTypes
        !           993:         
        !           994:         
        !           995:     manage_options = Folder.manage_options+(
        !           996:         {'label':'Main Config','action':'ECHO_navigationConfigForm'},
        !           997:         {'label':'Cache','action':'ECHO_cacheManageForm'},
        !           998:         {'label':'Main Config','action':'ECHO_copyright_configForm'},
        !           999:         {'label':'Change Weights','action':'changeWeights'},
        !          1000:         {'label':'Generate from RDF','action':'generateFromRDFForm'},
        !          1001:         {'label':'update Resource Catalog','action':'updateResourceCatalog'},
        !          1002:         {'label':'Copy MD for indexing and search','action':'copySearchFields'},
        !          1003:         )
        !          1004: 
        !          1005:     
        !          1006: def manage_addECHO_mainForm(self):
        !          1007:     """Form for adding"""
        !          1008:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)
        !          1009:     return pt()
        !          1010: 
        !          1011: def manage_addECHO_main(self,id,title,RESPONSE=None):
        !          1012:     """Add an ECHO_main"""
        !          1013:     self._setObject(id,ECHO_main(id,title))
        !          1014:     
        !          1015:     obj=self._getOb(id)
        !          1016:     text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()
        !          1017:     
        !          1018:     manage_addPageTemplate(obj,'main_template',text=text)               
        !          1019:     
        !          1020:   
        !          1021:     if RESPONSE is not None:
        !          1022:         RESPONSE.redirect('manage_main')
        !          1023: 
        !          1024:     
        !          1025:                              

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